C# Online Compiler | .NET Fiddle

<no name> by ddemurojs

using System;
using System.Collections.Generic;

public class Program
{
	public static void Main()
	{
		Console.WriteLine("Generic Test");
		Crap a = new Crap();
		a = Caller.doApiCall("");
		Console.WriteLine(a.ToString());

		// Failing test Animal -> Dog
		try {
			Software b = new Software();
			b = (Software)Caller.doApiCall("");
			Console.WriteLine(b.ToString());
		} catch {
			Console.WriteLine("\n\n\nThis will fail due to the Dog being an Animal but not all Animals are dogs situation \n\n\n");
		}

		// This will turn any animal and turn him into a dog. (The same you sent me)
		
		Crap w = Caller.doApiCall(""); 					// <--- Ignore the empty endpoint I'm simplifying it
		Software c = new Software();                    // <--- I turn our animal into a Dog
		Console.WriteLine(c.deserialize(w).ToString()); // <--- Now I can just call my dog
		
		// If you want to simplify it Select your class, this will allow you to turn your Crap object into Software in one line.
		Software z = new Software();
		Console.WriteLine(z.deserialize(Caller.doApiCall("")).ToString());
		
		Console.WriteLine("\n\n\nShowing generic works! \n\n\n");
		
		// Showing how generic works!
		RandomOther n = new RandomOther();
		Console.WriteLine(n.deserialize(Caller.doApiCall("")).ToString());
		
		Console.WriteLine("\n\n\nShowing up-casting works! \n\n\n");
		
		// Showing how generic works! (We can upcast safely to Crap and then Downcast safely again. Dog -> Animal -> Dog)
		Crap m = new RandomOther();
		Console.WriteLine(m.deserialize(Caller.doApiCall("")).ToString());
		RandomOther l = (RandomOther) m;
		Console.WriteLine(l.deserialize(Caller.doApiCall("")).ToString());
		
		/**
		The whole point here is, you're making generic (Crap) requests and then you specify the request
		to the class you're interested in.
		
		Since you want to keep everything generic you use:
		- ICrap as the "contract" everyone will use to ensure that you can turn a generic Crap into a specific Crap.
		- The specific part derived from Crap is obtained by parsing the Request by each specific class under Crap.
		- Crap can be used as your generic serial transport, when needed you can convert to specific.
			+---------------+
			|               |
			|Crap           +--------+
			|  (Generic)    |        |
			+------+--------+        |
				   |    Everyone implements ICrap
				   |                 |
			 +-----v-------+    +----v--------+
			 |             |    |             |
			 |  Software   |    | Printers    |
			 |             |    |             |
			 +-------------+    +-------------+
		
		This will be (I believe) the best way to keep each class responsible to "Deserialize" themselves.
		Will allow you flexibility on how you move data internally in the application.
		
		If you also want to extend the "Generic" component you can do so inside Crap class without adding it to the Interface. Essentially the Interface defines what the children MUST implement.
		Crap will then have common code to all children (Example, our Vehicle and Car). You'd put a wheel in the Vehicle, but the Car defines 4 wheels.
		
		//////////////////////////////////////
		# WARNING                            #
		//////////////////////////////////////
		This is because you cannot "down cast" safely, but you can upcast. Example:
		Crap c = new Crap();
		Software c = (Software) c; <= THIS IS INVALID!
		
		But,
		Software c = new Software()
		Crap w = (Crap)c; <= This is valid.
		
		And downcasting again should be fine too:
		Software z = (Software)c;
		
		Essentially, simplifying casting:
	    Dog -> Animal -> Dog should be safe. // All dogs are animals, once a dog, always a dog.
		Animal -> Dog    					 Exception, this is not safe, not all animals are dogs.
		*/
		
	}
}

public class Caller
{
	public static Crap doApiCall(string endpoint)
	{
		Crap apiResults = new Crap();
		// Assume that I got the response correctly, and status code, it's only as an example.
		apiResults.response = @"{  
									'ApplicationId':'325',
									'ComputerId':'3392'
								}";
		apiResults.statusCode = 200;
		return apiResults;
	}
}

/**
* Here we set the rules for our children
* this will allow us to assume that all the children from crap and crap have these methods always defined.
*/
public interface ICrap<T> {
	string ToString();
	T deserialize(Crap c);
	List<T> deserializeList(Crap c);
}

/**
* This class you cannot use, but will tell all other what you're trying to do.
* you cannot initialize it (using new) due to downcasting.
*/
public class Crap: ICrap<Crap>
{
	public int statusCode
	{
		get;
		set;
	}

	public string response
	{
		get;
		set;
	}

	public string error
	{
		get;
		set;
	}
	
	// In case downstream from Crap doesn't overwrite
	public override string ToString() {
		return "Crap: " + statusCode+" "+response;
	}
	
	// Just as an example
	public Crap deserialize(Crap c) {
		return c;
	}
	
	public List<Crap> deserializeList(Crap c) {
		//return JsonConvert.DeserializeObject<List<Crap>>(response);
		return new List<Crap>();
	}
}

public class RandomOther : Crap, ICrap<RandomOther>
{
	public int Application2Id
	{
		get;
		set;
	}

	public int Computer2Id
	{
		get;
		set;
	}
	
	public override string ToString() {
		return "RandomOther: " + statusCode+" "+response;
	}
	
	// Sample returning a list from a Crap request
	public new List<RandomOther> deserializeList(Crap c) {
		//return JsonConvert.DeserializeObject<List<Crap>>(response);
		return new List<RandomOther>();
	}
	
	public new RandomOther deserialize(Crap c)
	{
		// Here comes the logic of grabbing the response and turning it into an "object" of the class
		//return JsonConvert.DeserializeObject<List<RandomOther>>(response);
		this.response = c.response;
		this.statusCode = c.statusCode;
		this.Application2Id = 24;
		this.Computer2Id = 32;
		return this;
	}
}

public class Software : Crap, ICrap<Software>
{
	public int ApplicationId
	{
		get;
		set;
	}

	public int ComputerId
	{
		get;
		set;
	}

	public override string ToString() {
		return "Software: " + statusCode+" "+response;
	}

	// Sample returning a list from a Crap request
	public new List<Software> deserializeList(Crap c) {
		//return JsonConvert.DeserializeObject<List<Crap>>(response);
		return new List<Software>();
	}

	/*public string Name { get; set; }
	public string InstallationPath { get; set; }
	public DateTime DateInstalled { get; set; }
	public int Size { get; set; }
	public string UninstallerPath { get; set; }
	public string Version { get; set; }
	public DateTime DateLastInventoried { get; set; }
	public int ClientId { get; set; }
	public string ComputerName { get; set; }*/
	// Here comes the logic of grabbing the response and turning it into an "object" of the class
	//return JsonConvert.DeserializeObject<List<Software>>(response);
	public new Software deserialize(Crap c)
	{
		this.response = c.response;
		this.statusCode = c.statusCode;
		this.ApplicationId = 24;
		this.ComputerId = 32;
		return this;
	//return JsonConvert.DeserializeObject<List<Software>>(response);
	}
}

​x
 
using System;
using System.Collections.Generic;
​
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Generic Test");
        Crap a = new Crap();
        a = Caller.doApiCall("");
        Console.WriteLine(a.ToString());
​
        // Failing test Animal -> Dog
        try {
            Software b = new Software();
            b = (Software)Caller.doApiCall("");
            Console.WriteLine(b.ToString());
        } catch {
            Console.WriteLine("\n\n\nThis will fail due to the Dog being an Animal but not all Animals are dogs situation \n\n\n");
        }
​
        // This will turn any animal and turn him into a dog. (The same you sent me)
        
        Crap w = Caller.doApiCall("");                  // <--- Ignore the empty endpoint I'm simplifying it
        Software c = new Software();                    // <--- I turn our animal into a Dog
        Console.WriteLine(c.deserialize(w).ToString()); // <--- Now I can just call my dog
        
        // If you want to simplify it Select your class, this will allow you to turn your Crap object into Software in one line.
        Software z = new Software();
        Console.WriteLine(z.deserialize(Caller.doApiCall("")).ToString());
        
        Console.WriteLine("\n\n\nShowing generic works! \n\n\n");
        
        // Showing how generic works!
        RandomOther n = new RandomOther();
        Console.WriteLine(n.deserialize(Caller.doApiCall("")).ToString());
        
        Console.WriteLine("\n\n\nShowing up-casting works! \n\n\n");
        
        // Showing how generic works! (We can upcast safely to Crap and then Downcast safely again. Dog -> Animal -> Dog)
        Crap m = new RandomOther();
        Console.WriteLine(m.deserialize(Caller.doApiCall("")).ToString());
        RandomOther l = (RandomOther) m;
        Console.WriteLine(l.deserialize(Caller.doApiCall("")).ToString());
        
        /**
        The whole point here is, you're making generic (Crap) requests and then you specify the request
        to the class you're interested in.
        
        Since you want to keep everything generic you use:
        - ICrap as the "contract" everyone will use to ensure that you can turn a generic Crap into a specific Crap.
        - The specific part derived from Crap is obtained by parsing the Request by each specific class under Crap.
        - Crap can be used as your generic serial transport, when needed you can convert to specific.
            +---------------+
            |               |
            |Crap           +--------+
            |  (Generic)    |        |
            +------+--------+        |
                   |    Everyone implements ICrap
                   |                 |
             +-----v-------+    +----v--------+
             |             |    |             |
             |  Software   |    | Printers    |
             |             |    |             |
             +-------------+    +-------------+
        
        This will be (I believe) the best way to keep each class responsible to "Deserialize" themselves.
        Will allow you flexibility on how you move data internally in the application.
        
        If you also want to extend the "Generic" component you can do so inside Crap class without adding it to the Interface. Essentially the Interface defines what the children MUST implement.
        Crap will then have common code to all children (Example, our Vehicle and Car). You'd put a wheel in the Vehicle, but the Car defines 4 wheels.
        
        //////////////////////////////////////
        # WARNING                            #
        //////////////////////////////////////
        This is because you cannot "down cast" safely, but you can upcast. Example:
        Crap c = new Crap();
        Software c = (Software) c; <= THIS IS INVALID!
        
        But,
        Software c = new Software()
        Crap w = (Crap)c; <= This is valid.
        
        And downcasting again should be fine too:
        Software z = (Software)c;
        
        Essentially, simplifying casting:
        Dog -> Animal -> Dog should be safe. // All dogs are animals, once a dog, always a dog.
        Animal -> Dog                        Exception, this is not safe, not all animals are dogs.
        */
        
    }
}
​
public class Caller
{
    public static Crap doApiCall(string endpoint)
    {
        Crap apiResults = new Crap();
        // Assume that I got the response correctly, and status code, it's only as an example.
        apiResults.response = @"{  
                                    'ApplicationId':'325',
                                    'ComputerId':'3392'
                                }";
        apiResults.statusCode = 200;
        return apiResults;
    }
}
​
/**
* Here we set the rules for our children
* this will allow us to assume that all the children from crap and crap have these methods always defined.
*/
public interface ICrap<T> {
    string ToString();
    T deserialize(Crap c);
    List<T> deserializeList(Crap c);
}
​
/**
* This class you cannot use, but will tell all other what you're trying to do.
* you cannot initialize it (using new) due to downcasting.
*/
public class Crap: ICrap<Crap>
{
    public int statusCode
    {
        get;
        set;
    }
​
    public string response
    {
        get;
        set;
    }
​
    public string error
    {
        get;
        set;
    }
    
    // In case downstream from Crap doesn't overwrite
    public override string ToString() {
        return "Crap: " + statusCode+" "+response;
    }
    
    // Just as an example
    public Crap deserialize(Crap c) {
        return c;
    }
    
    public List<Crap> deserializeList(Crap c) {
        //return JsonConvert.DeserializeObject<List<Crap>>(response);
        return new List<Crap>();
    }
}
​
public class RandomOther : Crap, ICrap<RandomOther>
{
    public int Application2Id
    {
        get;
        set;
    }
​
    public int Computer2Id
    {
        get;
        set;
    }
    
    public override string ToString() {
        return "RandomOther: " + statusCode+" "+response;
    }
    
    // Sample returning a list from a Crap request
    public new List<RandomOther> deserializeList(Crap c) {
        //return JsonConvert.DeserializeObject<List<Crap>>(response);
        return new List<RandomOther>();
    }
    
    public new RandomOther deserialize(Crap c)
    {
        // Here comes the logic of grabbing the response and turning it into an "object" of the class
        //return JsonConvert.DeserializeObject<List<RandomOther>>(response);
        this.response = c.response;
        this.statusCode = c.statusCode;
        this.Application2Id = 24;
        this.Computer2Id = 32;
        return this;
    }
}
​
public class Software : Crap, ICrap<Software>
{
    public int ApplicationId
    {
        get;
        set;
    }
​
    public int ComputerId
    {
        get;
        set;
    }
​
    public override string ToString() {
        return "Software: " + statusCode+" "+response;
    }
​
    // Sample returning a list from a Crap request
    public new List<Software> deserializeList(Crap c) {
        //return JsonConvert.DeserializeObject<List<Crap>>(response);
        return new List<Software>();
    }
​
    /*public string Name { get; set; }
    public string InstallationPath { get; set; }
    public DateTime DateInstalled { get; set; }
    public int Size { get; set; }
    public string UninstallerPath { get; set; }
    public string Version { get; set; }
    public DateTime DateLastInventoried { get; set; }
    public int ClientId { get; set; }
    public string ComputerName { get; set; }*/
    // Here comes the logic of grabbing the response and turning it into an "object" of the class
    //return JsonConvert.DeserializeObject<List<Software>>(response);
    public new Software deserialize(Crap c)
    {
        this.response = c.response;
        this.statusCode = c.statusCode;
        this.ApplicationId = 24;
        this.ComputerId = 32;
        return this;
    //return JsonConvert.DeserializeObject<List<Software>>(response);
    }
}

View IL Code