C#

RESTResource r = /* set from somewhere else, but is actually a Category */;
  
//...

// Assume Get()'s return type is Category  
Category c = r.Get();

RESTResource r = /* set from somewhere else, but is actually a Category */;
  
//...

// Assume Get()'s return type is RESTResource
Category c = r.Get() as Category;
if (null != c)
    // c is a Category

public class RESTResource {
    public virtual RESTResource Get() {
        return new RESTResource();
    }
}

public class Category : RESTResource {
    public override RESTResource Get() {
        return new Category();
    }
}

// ... some other method ...
RESTResource r = new RESTResource();
RESTResource r2 = r.Get(); // returns a RESTResource

Category c = new Category();
Category c2 = c.Get() as Category; // returns a RESTResource, which is actually an instance of Category so we need to cast it.

Create<Category>();
   .
   .
   .

    public Response Create<T1>()
    {
        string url=//How can I get Category.endpoint_url here?
    }

    public class Category
    {
        public static string endpoint_url = "/categories";
        public int id;
        public string name;
        public int content_provider_id;

    } 

public class Test
{
  public Response Create<T1>()
  {
    string url=//How can I get Category.endpoint_url here?
  }
}

public class Category
{
    public static string endpoint_url = "/categories";
    public int id;
    public string name;
    public int content_provider_id;

}

public Response Create<T>() where T : MyBaseClass {
    T myClass = new T();
    String url = myClass.GetURL();
    // ....
}
  
// ...
  
public abstract class MyBaseClass {
    public abstract String GetURL();
  
    // Other method implementations can go here
}
  
public class Category : MyBaseClass {
    public static string endpoint_url = "/categories";
  
    public override String GetURL() {
        return Category.endpoint_url;
    }
}
  
// Then you can call Create like this, where t is of type Test
Response r = t.Create<Category>();

TJoe wrote:

If Category and any possible other classes have common functionality, then you should go with an abstract base class

public T Create() where T : ISomething, new()
{
  T item = new T();
  return item;
}

public class Category : RESTResource<Category>
{
}

public class RESTResource<T> where T : RESTResource, new()
{
  public <T> Get()
  {
    T item = new T();
    // do some work;
    return item;
  }
}

if ( a )
{
    if ( b )
    {
        ...
    }
}