Q:

C# mimic Java generic?

In Java this is valid: 
class Class1<T extends OtherType> { T t; ... }

//Inside other class that has no relation to Class1
private Class1 class1; //No type needed

public void someOtherFunction (Class1 class1) //Works  
{  
    this.class1 = class1; //May warn about invalid type casting
    class1.someFunction();
}

C# demands a type under the same conditions:
class Class1<T> where T : OtherType { T t; ... }

//Inside other class that has no relation to Class1
private Class1<TYPE DEMANDED> class1; //I don't know generic what type, and honestly it doesn't matter.

public void someOtherFunction (Class1 class1) //This is the definition I want to use, but C# Demands a type to class1 
public void someOtherFunction<T> (Class1<T> class1) where T : OtherType //C# Demands a type to class1 so I must specify a T
{  
    this.class1 = class1;
    class1.someFunction();
} //This function is valid but then it still needs the type to store it.

Is there any way to omit the type? It isn't necessary to know the type so why is it required? I can't make Class1 of type OtherType, because the point of the generic is to have an unknown type that extends the base of OtherType. I can work around it, but this is definitely the most efficient solution, if it were Java and I will have to type cast once a frame for multiple objects if this does not work, which I am worried will add up fast.
Actual code, per request:
public abstract class Weapon { ... }

public abstract class WeaponProxy<T> : MonoBehaviour where T : Weapon
{
    protected T weapon;

    public virtual void Update()
    {
        ...
        holdingPlayer = player.getHUD().showPickup(player, this);
        ...
    } 

public abstract class GunProxy<T> : WeaponProxy<T> where T : Gun
{

}

public abstract class Weapon
{
    private string weaponName;
    private string weaponIdentifier;
    private Player isHolding;

    public string getWeaponName () { return weaponName; }
    public Weapon(string weaponName, string weaponIdentifier)
    {
        this.weaponName = weaponName;
        this.weaponIdentifier = weaponIdentifier;
    }

    public void playerPickedUp (Player player)
    {
        this.isHolding = player;
    }

    public void playerDropped ()
    {
        this.isHolding = null;
    }
}

public class Gun : Weapon
{
  ...
}

public class HUD : MonoBehaviour
{
    private WeaponProxy weapon; //C# Needs a type. Underlined in red as error   

    public PlayerProxy showPickup<T> (PlayerProxy player, WeaponProxy<T> weapon) where T : Weapon
    {
        this.weapon = weapon;
        textPickupWeapon.text = "Hold '" + player.getPlayer().getControlScheme().getControlText(ControlScheme.CONTROLS.Interact) + "' to pick up " + weapon.getWeapon().getWeaponName();
        ...
    }
}

A:

Your java code is "valid" because all generics in java are actually non-generics, since java's generics are only a compile time trick, with no runtime support whatsoever.
For the java runtime, type A<T> is actually A with no type parameters, because the java runtime doesn't actually support generics at all.
In contrast, the .NET CLR has built-in support for runtime generic types, and hence it differentiates between a type A and a generic type A<T>.
In C#, if you want a non-generic version of type Class1, simply declare it:
class Class1
{
    //Whatever members that don't require a type parameter,

    void SomeFunction() { /* ... */ } // Please use proper casing.
}

then, if you need a generic version of this class:
class Class1<T>: Class1
{
    T Content { get; set; }
}

Now you will be able to have a member of type Class1 in any other class
class Example
{
    Class1 instance; // Valid

    public void someOtherFunction (Class1 class1) //Works  
    {  
        this.instance = class1; //Does not warn about anything because this is type safe.
        class1.SomeFunction(); // Works

        var content = class1.Content // Compile Error: type class1 does not have such member "Content"
    }
}

Notice how the C# approach is much safer, if you're using the non generic version, you can only access class members that are defined in the non generic version and do not require a type parameter. In contrast, java is totally unsafe, and may produce horrible runtime errors due to lack of real type safety in generics.

