We Keep Coding

c# Accessing an Object / Object Method when the Object is stored in a linked list

This application is supposed to be a sort of demo of how blockchain works. I have a block chain class and a block class and the program class is main. In the blockchain class I am creating an initial block called the gensis block in the createGenesisBlock() method. In the constructor of my blockchain class I am calling the createGenesisBlock() method and inserting the object into my linked-list which is called chain. The problem I have is when the object is added to the linked-list in my blockchain class I cannot access the object or the methods. What I am trying to accomplish is to use my getLatestBlock() method in the blockchain class to retrieve the value of hash of the last object that was put into chain. Thus being able to call my addBlock method in blockchain setting the value of previousHash equal to the value of hash of the object in the linked-list
namespace BlockChainProject
{
class Program
{
static void Main(string[] args)
{
Blockchain blockChain = new Blockchain();
blockChain.addBlock();
blockChain.display();
Console.ReadKey();
}
}
}
namespace BlockChainProject
{
class Block
{
private int index;
private string timeStamp;
private string data;
private string previousHash;
private string hash;
public Block(int index, string timeStamp, string data, string previousHash) {
this.index = index;
this.timeStamp = timeStamp;
this.data = data;
this.previousHash = previousHash;
this.hash = this.calculateHash();
}
public string calculateHash() {
SHA256Managed hashString = new SHA256Managed();
byte[] dataArray = hashString.ComputeHash(Encoding.UTF8.GetBytes(index.ToString() + previousHash + timeStamp + data));
StringBuilder stringBuilder = new StringBuilder();
foreach (byte x in dataArray)
{
stringBuilder.AppendFormat("{0:X2}", x);
}
string hashed = stringBuilder.ToString();
return hashed;
}
public string getHash() {
return hash;
}
}
}
namespace BlockChainProject
{
class Blockchain
{
LinkedList<object> chain;
private int index = 0;
private string time = DateTime.Now.ToString();
public Blockchain(){
chain = new LinkedList<object>();
chain.AddLast(createGenesisBlock());
}
private object createGenesisBlock() {
index++;
return new Block(index, time, "Genesis Block", "0"); ;
}
public object getLatestBlock() {
return chain.Last.Value;
}
public void addBlock() {
string data = Console.ReadLine();
//string previousHash = <The hash of linked lists last object here>;
chain.AddLast(new Block(index, time, data, previousHash));
index++;
}
public void display() {
foreach (var item in chain)
{
Console.WriteLine(item);
}
}
}
}

I quickly ran your code and I think that I have figured out your problem. You need to do a find and replace on "object" and replace it with "Block" or alternatively you need to cast the objects that are being returned from the getLast function to "Block".
An example of the changes will look like so:
LinkedList<Block> chain;
...
public Block getLatestBlock() {
return chain.Last.Value;
}
This is some examples of the changes to be made to the Blockchain class there may be others but I can't remember.
Now when you call the display function you have access to the functions and methods of each of the Block class instances in the linked list, like so:
public void display()
{
foreach (var item in chain)
{
Console.WriteLine(item.getHash());
}
}
This will now print a list of the hashes provided that you changed all of the returns, types and instances where you used object in the linked list, to Block.
The reason for this is if you create a linkedlist of generic "object"s then at compile time C# has no idea what might be in the linked lists. It could be Blocks or it could be Bananas, so it doesn't know what functions and methods each object will have available to call. So to let C# know we have to either cast it using "as Block" after we get the item from the list or in your case just set the type of all values in the linked like to "Block" as by the looks of your program you aren't going to have generic entries to the list.
Hopefully this answers your question. If not let me know.

When you specify your chain as
LinkedList<object> chain
You are telling the compiler that the chain variable is a linked list that contains an object class, or any descendent of object.
The following code is therefore legal by your definition of chain
chain.Add("Hi there!");
chain.Add(new Dictionary<int, decimal>());
chain.Add(new Giraffe());
chain.Add(42);
You cannot call calculateHash() because unfortunately, our string, Dictionary, Giraffe and int classes wouldn't know what to do with such a method call.
Instead, chain should be declared as
LinkedList<Block> chain;
This means that chain can only contain elements that are of type Block (or a descendent class of Block).
Whilst the calls to these methods are not shown in code, you will need to then change the createGenesisBlock() and getLatestBlock() methods to return Block rather than object, because you are not allowed to add just any object to your linked list anymore, it must be a Block.

Not sure how to implement a Constructor and then call it via instance

Okay, so I have a couple of questions. Let me first explain what I have to do. I made this code first, but without the constructor and the two methods had static in their declaration. Now I want to add a constructor that I was provided and I have to make it's instance in the main method, and afterwards provide it with some random values. I also need to call the two methods via an instance in the Main method. At the end, after compiling, it's supposed to say "Hello World!" and "81" So here come the questions:
Are the variables in the constructor supposed to be the named the same as the ones in the methods?
How do I create an instance of the constructor in the main method?
How do I give it some random values?
How do I call the two methods via their instances?
The code:
namespace CalculatorA
{
class Calculator
{
public string WriteText(string parametar1)
{
return parametar1;
}
public int WriteNumber(int parametar2)
{
return parametar2;
}
public Calculator(int operand1, int operand2)
{
this.operand1 = operand1;
this.operand2 = operand2;
}
}
class Program
{
static void Main(string[] args)
{
string s = Calculator.WriteText("Hello World!");
Console.WriteLine(s);
string n = Calculator.WriteNumber(53 + 28).ToString();
Console.WriteLine(n);
Console.ReadLine();
}
}
}

I think you are lacking some object oriented programming concepts. Constructor is pretty much a method that initializes an instance of a class.
Are the variables in the constructor supposed to be the named the same
as the ones in the methods?
Constructor parameters have to be named. But there is no connection between constructor params and method params. These are just separate members of a class.
How do I create an instance of the constructor in the main method?
You create an instance of a class but not a constructor. Although construction is being called when you initiate an object using new keyword.
How do I give it some random values?
Depending on the type. For integer for example you can use new Random().Next().
How do I call the two methods via their instances?
I guess... just call... Just like that:
calc.Method1();
calc.Method2();

Question 1:
Yes and No - Yes because they can be named similarly or identically and still function because of their scope. No because in your example code you would want them to represent what values they'll be holding so you can, at a glance, understand their purpose. For simplicity, in the examples I display I will keep them as named in your example.
I suggest googling Scope and lifetime of Variables and Naming Conventions.
Also, it would be wise to apply either fields or properties to your Calculator class so the constructors values are stored for use by the methods within the class. Should this be your intent for the parameters.
Question 2:
Create an instance of the Calculator class
var calc = new Calculator(); //calc can be named to anything you want.
Question 3:
Using a instance of System.Random then producing a variety of random numbers like so.
var rnd = new Random();
var randomNumber1 = rnd.Next(0, 100);
var randomNumber2 = rnd.Next(0, 100);
//then using those in your Calculator.WriteNumber()
var calc = new Calculator(1,2); //without fields/properties this could be erroneous
var result = calc.WriteNumber(randomNumber1 + randomNumber2); //returns the sum of those to params.
Question 4:
You need to initialize an instance of the Calculator class - See Question 2. Then use that variable to access the methods eg:
var result = calc.WriteNumber(2); //returns 2
//or
var result = calc.WriteNumber(53 + 28); //returns 81
Here is some working code that you can learn from example. Hope this helps.
static void Main(string[] args)
{
//Create random numbers
var rnd = new Random();
var randomNumber1 = rnd.Next(1, 100); //get a random int between 1 and 99
var randomNumber2 = rnd.Next(1, 100); //and again
//Create instance of Calculator Class
var calc = new Calculator(randomNumber1, randomNumber2);
//Intro
string s = calc.WriteText("Hello World!");
Console.WriteLine(s);
//Do your addition method
var n = calc.WriteNumber(53 + 28);
Console.WriteLine(n);
//Do new addition method
var result = calc.Add(); //Returns _operand1 + _operand2
Console.WriteLine(result);
//exit application
Console.ReadLine();
}
class Calculator
{
// Set fields for your constructor to use.
// Another valid option is using properties, google this as its beyond the scope of a basic tutorial
private int _operand1, _operand2;
public string WriteText(string parametar1)
{
return parametar1;
}
public int WriteNumber(int parametar2)
{
return parametar2;
}
public int Add()
{
return _operand1 + _operand2;
}
public Calculator(int operand1, int operand2)
{
//You don't need the this keyword
_operand1 = operand1;
_operand2 = operand2;
}
}

The object's fields don't have to be the same as the constructor's parameters, although it is common for that to be the case.
var calculator = new Calculator(53,28);
Use the Random class
calculator.WriteNumber(53+28);

Are the variables in the constructor supposed to be the named the same as the ones in the methods?
The variables you have used in the constructor are not declared in the class.
your class should be like this:
class Calculator
{
private int operand1 {get; set;} //need to declare the var before using
private int operand2 {get; set;}
private string Message {get; set;}
public string WriteText() //you don't need to send parameters to the function if you have already got them in the contructor
{
return Message;
}
public int GetSum()
{
return operand1 + operand2;
}
public Calculator(string Message, int operand1, int operand2)
{
this.Message = Message;
this.operand1 = operand1;
this.operand2 = operand2;
}
}
class Program
{
static void Main(string[] args)
{
Calculator CalcObj = new Calculator ("Hello word!", 53, 28); //That is how you can initialize a class object
string s = Calculator.WriteText(); //this will return you the string you passed in controller
Console.WriteLine(s);
string n = Calculator.GetSum().ToString(); //that will give you sum of two operand
Console.WriteLine(n);
Console.ReadLine();
}
}
For random numbers you can use
Random() method in C# to generate random numbers in main method and pass them to the contructor of the class and GetSum will give you some of those numbers

Performance difference in empty array initialization

Recently, I've been working in performance/memory optimization and have stucked in the empty array initialization which uses generic method to initialize empty array:
Code implementation of generic empty array class:
public static class EmptyArray<T>
{
public static readonly T[] Instance;
static EmptyArray()
{
Instance = new T[0];
}
}
So, whenever creating empty array of any type,it has been called as like:
var emptyStringArray = EmptyArray<string>.Instance;
Such empty array declaration has been done in many places of codebase. I am confused how would it be differs in performance while using :
var emptyStringArray = new string[0];
I've asked to above code author and he has replied me :
Basically, all empty arrays are readonly, and are equal to one
another, which means that you can use the same instance (which will be
created lazily on demand during run-time)… That should reduce the
total number of allocations, reduce memory usage and GC pressure, and
should result in some improvement
Still, I am not able to understand how would EmptyArray Instance boost the performance in array declaration.
Is there any performance difference in code using following approach :
1st Approach :
var emptyStrArr = EmptyArray<string>.Instance;
var emptyFooArr = EmptyArray<Foo>.Instance;
var emptyBarArr = EmptyArray<Bar>.Instance;
2nd Approach :
var emptyStrArr = new string[0];
var emptyFooArr = new Foo[0];
var emptyBarArr = new Bar[0];

In the first code the static constructor is executed only once.So you are just creating one array and using it all the time. In the second code you are creating an array instance each time. That's the difference.
You can see it more cleary by changing the constructor:
static EmptyArray()
{
Instance = new T[0];
Console.WriteLine("Array of "+ typeof(T) + " is created.");
}
var s = EmptyArray<string>.Instance;
s = EmptyArray<string>.Instance;
s = EmptyArray<string>.Instance;
var i = EmptyArray<int>.Instance;
i = EmptyArray<int>.Instance;
// output:
// Array of System.String is created.
// Array of System.Int32 is created.

This:
var emptyStringArray = new string[0];
Creates a new instance of an empty string array every time its called, with all the associated memory allocation overhead, whereas this:
public static class EmptyArray<T>
{
public static readonly T[] Instance;
static EmptyArray()
{
Instance = new T[0];
}
}
Only ever creates a single instance of the empty string array, regardless of how many times you call the Instance field.

jus to illustrate a bit how this can boost performance and memory you can try this
using System;
namespace ConsoleApplication11
{
class Program
{
static void Main(string[] args)
{
var str = EmptyArray<string>.Instance;
var intTest = EmptyArray<int>.Instance;
var intTest1 = EmptyArray<int>.Instance;
var str1 = EmptyArray<string>.Instance;
Console.WriteLine(str.GetType());
Console.WriteLine(intTest.GetType());
if (ReferenceEquals(str,str1))
{
Console.WriteLine("References are equals");
}
if (ReferenceEquals(intTest,intTest1))
{
Console.WriteLine("References are equals");
}
}
}
public static class EmptyArray<T>
{
public static readonly T[] Instance;
static EmptyArray()
{
Instance = new T[0];
}
}
}
you can see that no other allocation is needed even for value type and given that allocation and destruction of objects it's time and memory consuming you can enhance your code by doing this

Using variable calling another one

So im new at C# and i need to know if what i want to do is possible and how heres what I have,
public static class Sempre
{
public static string Raca = "";
}
// Sempre.Raca - can use like this
Now What I want to do is set a variable like thing = "example", and after this call Sempre but with the variable something like, Sempre.thing, but because it's a variable it would actually be Sempre.example.
Example same use I want in php,
$example = mean;
$_SESSION['name'.$example];
would create $_SESSION [namemean];

You can setup your type with an indexer. http://msdn.microsoft.com/en-us/library/6x16t2tx.aspx. To use the indexer, you are required to have an instance class rather than a static one. If you really need to, you can use the singleton pattern to get "static" behavior.
Here is an example of using an indexer:
public class Sempre
{
private Dictionary<string, string> _values = new Dictionary<string, string>();
public string this[string key]
{
get { return _values[key]; }
set { _values[key] = value; }
}
}
You can use it like this:
Sempre sempre = new Sempre();
sempre["example"] = "my value";
string thing = "example";
Console.WriteLine(sempre[thing]);

Generally speaking you can not do this with objects in C# since the code is precompiled prior to runtime.
If you are specifically looking for an implementation of http session state, like you have in the PHP code example then this could be done. Session State is exposed at System.Web.SessionState.HttpSessionState and can be accessed via concatenated strings like in your example like this.
String example = "mean";
Session["name" + example] = 'bar';
//Session["namemean"] is now set to value of 'bar'

If you're only looking to do string substitution, you can also do something like this:
public class StringConstants
{
public static string YES = "yes";
public static string NO = "no";
}
then elsewhere
public void printmessage(bool value)
{
if (value)
{
Console.writeline (string.Format "I Say {0}", StringConstants.YES);
}
else
{
Console.writeline (string.Format "I Say {0}", StringConstants.NO);
}
}
Documentation on string.Format for insertions and compositions is here

How to specify defaults for a plugin function in C#

I'm trying to implement a simple plugin system which will allow people to write the following:
[Plugin("A plugin function")]
public static int PluginFunction(int a, int b)
{
return a + b;
}
and then drop the DLL containing this function into a folder where it will be scanned by the application and show up as an available function at runtime. This all works fine, so far so good, the PluginAttribute class is what you would expect, just a description string for the function.
However, I'd like to allow the plugin writer to specify default values for the parameters. This is OK for values which are constant at compile time and then deduced via reflection, but I'd like a way to specify defaults for more complex types which will be created at runtime. Has anyone implemented something similar? The primary goal is to make it simple to implement plugin functions - I'm trying to avoid complex scaffolding but accept that my nice simple system is not going to cut it if I want this feature. I'm also happy to have some complexity in the application code which makes the system appear simple to the plugin writer.
Thanks,
Charlie.
Update:
I'm going with a combination of what's been suggested here, the closest is what Peter O. came up with - here's a version:
[Plugin("A plugin function")]
[Defaults(typeof(AdderDefaults))]
public static int Adder(int a, int b)
{
return a + b;
}
public static class AdderDefaults
{
public static int a { get { return 1; } }
public static int b { get { return 2; } }
}
[Plugin("Another plugin function")]
[Defaults(typeof(TexturizerDefaults))]
public static Bitmap Texturize(Bitmap source, Point offset)
{
return result;
}
public static class TexturizerDefaults
{
// no default for source parameter
public static Point offset { get { return new Point(16, 16); } }
}
This allows parameters to be skipped and specified by name. No compile time checking but that's OK - checking these at runtime is acceptable.

Maybe you can create an attribute which refers to a type
containing default values for the plugin. Example:
[PluginDefaults(typeof(MyPluginDefaults))]
The class MyPluginDefaults could then look like:
public class MyPluginDefaults {
int Parameter1 { // First parameter
get { return 0; } // default value for 'a'
}
int Parameter2 { // Second parameter
get { return 4; } // default value for 'b'
}
// Additional parameters would be called Parameter3, Parameter4, and so on.
}

There are lots of way to do that, the simpliest is to use a simple convention :
[Plugin("A plugin function")]
public static int PluginFunction(int a, int b)
{
return a + b;
}
public static object[] PluginFunctionDefaultArguments()
{
return new [] { 0, 0 };
}
Each time you find a function marked with PluginAttribute search for a function having the same name with the DefaultArguments sufix, no parameters and an object[] return type. Then call it and store the values somewhere. You should also support the default values to be specifed using the dedicated C#/VB syntax (it is found in the DefaultValue member for the parameter)

One way would be to have property Defaults for each of the classes. It returns an object that can be queried for the defaults, for example like this:
object[] pluginFunctionDefaults = FooPlugin.Defaults["PluginFunction"];
(Obviously, you wouldn't have code exactly like this in your application.)
And the declaration of the defaults could look like this:
class FooPlugin
{
static FooPlugin()
{
var bar = new Bar();
Defaults = new DefaultValues()
.Add(() => PluginFunction(42, 13))
.Add(() => AnotherFunction(bar));
}
public static DefaultValues Defaults { get; private set; }
// actual methods of the class
}
Using expressions like this means that the types of the defaults are checked at compile time. The DefaultValues class parses the expressions and stores the parameters. It could look something like this:
class DefaultValues
{
private readonly Dictionary<string, object[]> m_expressions =
new Dictionary<string, object[]>();
public DefaultValues Add<T>(Expression<Func<T>> func)
{
var methodCall = ((MethodCallExpression)func.Body);
var name = methodCall.Method.Name;
var arguments =
methodCall.Arguments
.Select(Evaluate)
.ToArray();
m_expressions.Add(name, arguments);
return this;
}
private static object Evaluate(Expression expression)
{
return Expression.Lambda<Func<object>>(
Expression.Convert(expression, typeof(object)))
.Compile()();
}
public object[] this[string methodName]
{
get { return m_expressions[methodName]; }
}
}