We Keep Coding

How do you return an array in a procedure back to the main procedure in C#?

static string readfileName(string[] name)
{
using (StreamReader file = new StreamReader("StudentMarks.txt"))
{
int counter = 0;
string ln;
while ((ln = file.ReadLine()) != null)
{
if (ln.Length > 4)
{
name[counter] = ln;
counter++;
}
}
file.Close();
return name;
}
}
This is the procedure I'm currently trying to return the array name[50] but the compile time error I can't fix states
"Error CS0029 Cannot implicitly convert type 'string[]' to 'string' "

You don't need to. Your main method passed the array to this method, this method filled it. It doesn't need to hand it back because the object pointed to by your 'name` variable is the same object as pointed to by the original variable in the main method; your main method already has all the array data:
static void Main(){
var x = new string[10];
MyMethod(x);
Console.Write(x[0]); //prints "Hello"
}
static void MyMethod(string[] y){
y[0] = "Hello";
}
In this demo code above we start out with an array of size 10 that is referred to by a variable x. In memory it looks like:
x --refers to--> arraydata
When you call MyMethod and pass x in, c# will create another reference y that points to the same data:
x --refers to--> arraydata <--refers to-- y
Now because both references point to the same area of memory anything that you do with y, will also affect what x sees. You put a string (like I did with Hello) in slot 0, both x and y see it. When MyMethod finishes, the reference y is thrown away, but x survives and sees all the changes you made when working with y
The only thing you can't do is point y itself to another different array object somewhere else in memory. That won't change x. You can't do this:
static void MyMethod(string[] y){
y = new string[20];
}
If you do this your useful reference of x and y pointing to the same area of memory:
x ---> array10 <--- y
Will change to:
x ---> array10 y ---> array20
And then the whole array20 and the y reference will be thrown away when MyMethod finishes.
The same rule applies if you call a method that supplies you an array:
static void MyMethod(string[] y){
y = File.ReadAllLines("some path"); //this also points y away to a new array made by ReadAllLines
}
It doesn't matter how or who makes the new array. Just remember that you can fiddle with the contents of an object pointed to by y all you like and the changes will be seen by x, but you can't change out the entire object pointed to by y and hope x will see it
in that case you WOULD have to pass it back when you're done:
static string[] MyMethod(string[] y){
y = new ...
return y;
}
And the main method would have to capture the change:
Main(...){
string[] x = new string[10];
string[] result = MyMethod(x);
}
Now, while I'm giving this mini lesson of "pass by reference" and "pass by value" (which should have been called "pass by original reference" and "pass by copy of reference") it would be useful to note that there is a way to change things so MyMethod can swap y out for a whole new object and x will see the change too.
We don't really use it, ever; there is rarely any need to. Just about the only time it's used is in things like int.Parse. I'm telling you for completeness if education so that if you encounter it you understand it but you should always prefer a "change the contents but not the whole object" or a "if you make a new object pass it back" approach
By marking the y argument with the ref keyword, c# wont make a copy of the reference when calling the method, it will use the original reference and temporarily allow you to call it y:
static void MyMethod(ref string[] y){
y = new array[20];
}
Our diagram:
x ---> array10data
Temporarily becomes:
x a.k.a y ---> array10data
So if you point y to a new array, x experiences the change too, because they're the same reference; y is no longer a different reference to the same data
x a.k.a y ---> array20data
Like I say, don't use it- we always seek to avoid it for various reasons.
Now, I said at the start "you don't need to" - by that, and for the reasons above, I meant you don't need to return anything from this method
Your method receives the array it shall fill (from the file) as a parameter; it doesn't make a new array anywhere so there isn't any need to return the array when done. It will just put any line longer than 4 chars into an array slot. It could then finish without returning anything and the method that called this method will see the changes it made in the array. This is just like my code, where MyMethod changes slot 0 of the array, MyMethod was declared as void so it didn't need to make a return statement , and my Main method god could still see the Hello that I put in the array. In the same vein, your Main method will see all those lines from the file if you make your ReadFileName method (which should perhaps be called FillArray) because it fills the array called name
The most useful thing your method could return is actually an integer saying how many lines were read; the array passed in is of a fixed size. You can't resize it because that entails making a new array which won't work for all those reasons I talked about above. If you were to make a new array and return it there wouldn't be any point in passing an array in.
There are thus several ways we could improve this code but to my mind they come down to two:
don't pass an array in; let this method make a new array and return it. The new array passed back can be exactly sized to fit
keep with the "pass an array in" idea and return an integer of how many lines were actually read instead
For the second idea (which is the simplest to implement) you have to change the return type to int:
static int ReadFileName(string[] name)
And you have to return that variable you use to track which slot to put the next thing in, counter. Counter is always 1 greater than the number of things you've stored so:
return counter - 1;
Your calling method can now look like:
string[] fileData = new string[10000]; //needs to be big enough to hold the whole file!
int numberOfLinesRead = ReadFileName(fileData);
Can you see now why ReadFileName is a bad name for the method? Calling it FillArrayFromFile would be better. This last line of code doesn't read like a book, it doesn't make sense from a natural language perspective. Why would something that looks like it reads a file name (if that even makes sense) take an array and return an int - calling it ReadFileName makes it sound more like it searches an array for a filename and returns the slot number it was found in. Here ends the "name your methods appropriately 101"
So the other idea was to have the Read method make its own array and return it. While we are at it, let's call it ReadFileNamed, and have it take a file path in so it's not hard coded to reading just that one file. And we will have it return an array
static string[] ReadFileNamed(string filepath)
^^^^^^^^ ^^^^^^^^^^^^^^^
the return type the argument passed in
Make it so the first thing it does is declare an array big enough to hold the file (there are still problems with this idea, but this is programming 101; I'll let them go. Can't fix everything using stuff you haven't been taught yet)
Put this somewhere sensible:
string lines = new string[10000];
And change all your occurrences of "name" to be "lines" instead - again we name our variables we'll just like we name our methods sensibly
Change the line that reads the fixed filename to use the variable name we pass in..
using (StreamReader file = new StreamReader(filepath))
At the end of the method, the only thing left to do is size the array accurately before we return it. For a 49 line file, counter will be 50 so let's make an array that is 49 big and then fill it using a loop (I doubt you've been shown Array.Copy)
string[] toReturn = new string[counter-1];
for(int x = 0; x < toReturn.Length; x++)
toReturn[x] = lines[x];
return toReturn;
And now call it like this:
string[] fileLines = ReadFileNamed("student marks.txt");

If you're looking to return name[50] and you know that will be populated, why not go with:
static string readfileName(string[] name)
{
using (StreamReader file = new StreamReader("StudentMarks.txt"))
{
int counter = 0;
string ln;
while ((ln = file.ReadLine()) != null)
{
if (ln.Length > 4)
{
name[counter] = ln;
counter++;
}
}
file.Close();
return name[50];
}
}
You're getting the error because your method signature indicates that you're going to return a string, but you're defining name as a string[] in the argument. If you simply select a single index of your array in the return statement, you'll only return a string.

You have defined your method to return a string, yet the code inside is returning name, which is a string[]. If you want it to return a string[], then change the signature to specify that:
static string[] ReadFileName(string[] name)
However, since your method is only populating the array that was passed in, it's not really necessary to return the array, since the caller already has a reference to the array we're modifying (they passed it to our method in the first place).
There is a potential problem here, though
We're expecting the caller to pass us an array of the appropriate length to hold all the valid lines from the file, yet that number is unknown until we read the file. We could return an array of the size they specified with either empty indexes at the end if it was too big, or incomplete data if it was too small, but instead we should probably just return them a new array, and not require them to pass one to us.
Note that it's easier to use a List<string> instead of a string[], since lists don't require any knowledge of their size at instantiation (they can grow dynamically). Also, we no longer need a counter variable (since we're using the Add method of the list to add new items), and we can remove the file.Close() call since the using block will call that automatically (one of the cool things about them):
static string[] ReadFileName()
{
List<string> validLines = new List<string>();
using (StreamReader file = new StreamReader("StudentMarks.txt"))
{
string ln;
while ((ln = file.ReadLine()) != null)
{
if (ln.Length > 4)
{
validLines.Add(ln);
}
}
}
return validLines.ToArray();
}
And we can simplify the code even more if we use some static methods of the System.IO.File class:
static string[] ReadFileName()
{
return File.ReadLines("StudentMarks.txt").Where(line => line.Length > 4).ToArray();
}
We could also make the method a little more robust by allowing the caller to specify the file name as well as the minimum line length requirement:
static string[] ReadFileName(string fileName, int minLineLength)
{
return File.ReadLines(fileName)
.Where(line => line.Length >= minLineLength).ToArray();
}

Well, you are trying to do several thing in one method:
Read "StudentMarks.txt" file
Put top lines into name existing array (what if you have too few lines in the file?)
return 50th (magic number!) item
If you insist on such implementation:
using System.Linq;
...
static string readfileName(string[] name)
{
var data = File
.ReadLines("StudentMarks.txt")
.Where(line => line.Length > 4)
.Take(name.Length);
int counter = 0;
foreach (item in data)
if (counter < name.Length)
name[counter++] = item;
return name.Length > 50 ? name[50] : "";
}
However, I suggest doing all things separately:
// Reading file lines, materialize them into string[] name
string[] name = File
.ReadLines("StudentMarks.txt")
.Where(line => line.Length > 4)
// .Take(51) // uncomment, if you want at most 51 items
.ToArray();
...
// 50th item of string[] name if any
string item50 = name.Length > 50 ? name[50] : "";
Edit: Splitting single record (name and score) into different collections (name[] and score[]?) often is a bad idea;
the criterium itself (line.Length > 4) is dubious as well (what if we have Lee - 3 letter name - with 187 score?).
Let's implement Finite State Machine with 2 states (when we read name or score) and read (name, score) pairs:
var data = File
.ReadLines("StudentMarks.txt")
.Select(line => line.Trim())
.Where(line => !string.IsNullOrEmpty(line));
List<(string name, int score)> namesAndScores = new List<(string name, int score)>();
string currentName = null;
foreach (string item in data) {
if (null == currentName)
currentName = item;
else {
namesAndScores.Add((currentName, int.Parse(item)));
currentName = null;
}
}
Now it's easy to deal with namesAndScores:
// 25th student and his/her score:
if (namesAndScores.Count > 25)
Console.Write($"{namesAndScores[25].name} achieve {namesAndScores[25].score}");

How to add more than one element to my list/array in C# while reading a file, so I can print all on one line per line of the text?

Help me find out how to add the full array i created into one line, It looks like by changing the int to double to big error changes, so for now I just want to try to add everything on the whole line.
It seems when i try to add a array it prints out the name of the array, when i try to print out the array instance name it prints the file pathway, when i add split array[0] it successfully prints the first element in the array. How can I add the whole array and not just the first element?
This is what the text looks like:
regular,bread,2.00,2
regular,milk,2.00,3
This is what I want it to look like after coded
regular,bread,2.00,2,(the result of 2*2*GST)
regular,milk,2.00,3,(the result of 2*3*GST)
This is what I get it(dont need to show regular item cost string):
System.Collections.Generic.List`1[System.String]
RegularItemCost:
4.4
This is the code I have got for reading and the method and constructors for calculations:
public List<string> readFile()
{
string line = "";
StreamReader reader = new StreamReader("groceries.txt"); //variable reader to read file
while ((line = reader.ReadLine()) != null) //reader reads each line while the lines is not blank, line is assigned value of reader
{
line = line.Trim(); //gets rid of any spaces on each iteration within the line
if (line.Length > 0) //during each line the below actions are performed
{
string[] splitArray = line.Split(new char[] { ',' }); //creates a array called splitArray which splits each line into an array and a new char
type = splitArray[0]; // type is assigned for each line at position [0] on
name = splitArray[1]; //name is assigned at position [1]
//<<<-------food cost calculation methods initialized-------->>>>
RegularItem purchasedItem = new RegularItem(splitArray); //purchased Item is the each line to be printed
FreshItem freshItem = new FreshItem(splitArray);
double regCost = purchasedItem.getRegularCost(); //regCost will multiply array at position [2] with [3]
double freshCost = freshItem.getFreshItemCost();
string[] arrayList = { Convert.ToString(regCost), Convert.ToString(freshCost) };
List<string> newArray = new List<string>(splitArray);
newArray.AddRange(arrayList);
if (type == "regular")
{
// items.InsertRange(4, (arrayList)); //first write a line in the list with the each line written
items.Add(Convert.ToString(newArray));
items.Add("RegularItemCost:");
items.Add(Convert.ToString(regCost)); //next add the regCost method to write a line with the cost of that item
}
else if (type == "fresh")
{
items.Add(Convert.ToString(freshItem)); //first write a line in the list with the each line written
items.Add("FreshItemCost:");
items.Add(Convert.ToString(freshCost)); //next add the fresh method to write another line with the cost of that item
}
}
}
return items;
}
//constrctor and method
public class RegularItem : GroceryItem //inheriting properties from class GroceryItem
{
private string[] splitArray;
public RegularItem()
{
}
public RegularItem(string[] splitArray) //enables constructor for RegularItem to split into array
{
this.type = splitArray[0];
this.name = splitArray[1];
this.price = double.Parse(splitArray[2]); //each line at position 4 is a double
this.quantity = double.Parse(splitArray[3]); //each line at position 3 is parsed to an integer
}
public double getRegularCost() //method from cost of regular
{
return this.price * this.quantity * 1.1; //workout out cost for purchases including GST
}
}

Ok, multiple things. First, while it's not bad to use Convert. ToString(), i think is better to just do . ToString. Remember all objects inherit from object so all objects will have that method.
If you want all the values of a collection to be "joined" into one string beter use string. Join(), look at it, you can specify a separatorto use between values. If you just use the Convert. ToString() directly on the list it just print the information about the list object itself, not the values inside the list.
Next, if you use ToString or Convert. ToString with a built-in type like int or double, it will print the number as a string, but if you do it with your custom object or simply with a more conplex object like List it will just print the type info. To solve this in your custom objects (like RegularItem f. I.) you must override the ToString() method an code there what you want to print when the method get called. So you can override the method and put there to print the cost dor example.

Display unique number before array beginning C#

I was working on a small program that basically reads from a txt multiple arrays and writes them to another file, but, additionally, it should generate a unique number and place it just before the information. I got the first part working with no problems but the second part is causing me problems even though it should work.
public static void Main(string[] args)
{
StreamReader vehiclereader = new StreamReader(#"C:\Users\Admin\Desktop\Program\vehicles.txt");
string line = vehiclereader.ReadToEnd();
string ID;
string category;
string Type;
string Brand;
string Model;
string Year;
string Colour;
while (line != null)
{
var parts = line.Split(',');
Type = parts[0];
Brand = parts[1];
Model = parts[2];
Year = parts[3];
Colour = parts[4];
Console.WriteLine(line);
string[] lines = { line };
System.IO.File.WriteAllLines(#"C:\Users\Admin\Desktop\Program\vehicles2.txt", lines);
List<string> categories = new List<string>();
categories.Add(Type);
int count = categories.Where(x => x.Equals(Type)).Count();
ID = Type.Substring(0, 4) + count.ToString("00");
Console.ReadKey();
}
}
}
Currently, this code reads from a txt file, displays it into the console and writes it back to another txt file. This is fine, the part that is not willing to work is the unique number generator.
Last 5 lines of code are supposed to add a unique number just before 'Type' data and would always start from 001. If the 'Type' data is identical, then the number just grows in ascending order. Otherwise, the unique number should reset for new types and start counting from 001 and should keep growing for identical types. (e.g. For all lightweight vehicles the counter should be the same and for heavyweight vehicles the counter should be different but count all of the heavy vehicles)
I'm open to any help or suggestions!

There are a variety of issues and suggestions with this code, allow me to list them before providing a corrected version:
StreamReader is disposable, so put it in a "using" block.
ReadToEnd reads the entire file into a single string, whereas your code structure is expecting it to return a line at a time, so you want the "ReadLine" method.
The value of line does not get modified within your loop, so you will get an infinite loop (program that never ends).
(Suggestion) Use lower case letters at the start of your variable names, it will help you spot what things are variables and what are classes/methods.
(Suggestion) The local variables are declared in a wider scope than they are needed. There is no performance hit to only declaring them within the loop, and it makes your program easier to read.
"string[] lines = { line };" The naming implies that you think this will split the single line into an array of lines. But actually, it will just create an array with one item in it (which we've already established is the entire contents of the file).
"category" is an unused variable; but actually, you don't use Brand, Model, Year or Colour either.
It would have helped if the question had a couple of lines as an example of input and output.
Since, you're processing a line at a time, we might as well write the output file a line at a time, rather than hold the entire file in memory at once.
The ID is unused, and that code is after the line writing the output file, so there is no way it will appear in there.
"int count = categories.Where(x => x.Equals(type)).Count();" is inefficient, as it iterates through the list twice: prefer "int count = categories.Count(x => x.Equals(type));"
Removed the "Console.Write", since the output goes to a file.
Is that "Console.ReadKey" meant to be within the loop, or after it? I put it outside.
I created a class to be responsible for the counting, to demonstrate how it is possible to "separate concerns".
Clearly I don't have your files, so I don't know whether this will work.
class Program
{
public static void Main(string[] args)
{
var typeCounter = new TypeCounter();
using (StreamWriter vehicleWriter = new StreamWriter(#"C:\Users\Admin\Desktop\Program\vehicles2.txt"))
using (StreamReader vehicleReader = new StreamReader(#"C:\Users\Admin\Desktop\Program\vehicles.txt"))
{
string line;
while ((line = vehicleReader.ReadLine()) != null)
{
var parts = line.Split(',');
string type = parts[0].Substring(0, 4); // not sure why you're using substring, I'm just matching what you did
var identifier = typeCounter.GetIdentifier(type);
vehicleWriter.WriteLine($"{identifier},{line}");
}
}
Console.ReadKey();
}
}
public class TypeCounter
{
private IDictionary<string, int> _typeCount = new Dictionary<string, int>();
public string GetIdentifier(string type)
{
int number;
if (_typeCount.ContainsKey(type))
{
number = ++_typeCount[type];
}
else
{
number = 1;
_typeCount.Add(type, number);
}
return $"{type}{number:00}"; // feel free to use more zeros
}
}

Random Number Generated from File Input

I am new to programming in C# and I'm having problems generating random numbers from input read form a file. I am trying to generate random numbers from the second field on each line from the following input read from a text file
4321,99
5432,79
6543,59
7654,39
The file is read by the following code, then parsed into separate fields where a method is called to generate a random number
private void readFileButton_Click(object sender, EventArgs e)
{
string readString;
inputFile = File.OpenText(sourceFileString);
while (!inputFile.EndOfStream)
{
readString = inputFile.ReadLine();
var flds = readString.Split(',');
string patID = flds[0];
int months = Convert.ToInt32(flds[1]);
Random();
}
inputFile.Close();
}
The method I am using that generates a random number from the second field
private void Random()
{
Random rand2Integer = new Random();
randomInteger = rand2Integer.Next(1, months) + 1;
}
However, this exception is thrown: 'minValue' cannot be greater than maxValue, and I can't wrap my head around it. If I manually enter the data on a form using a text box then the random number is generated as expected. Any input to guide me along?

From your code it looks like you have a class variable months. However, while reading file you have declared a local variable which essentially hides the class variable.
Now when you use Random function, the class variable is used (which must have 0 and causing this error)
replace the following line of code
int months = Convert.ToInt32(flds[1]);
with
months = Convert.ToInt32(flds[1]);

The variable months in Random() is not the same that the one you are assigning in int months = Convert.ToInt32(flds[1]); the last is local to the method.
You should define month outside or pass it as a parameter to Random()
EDIT:
I made minor changes to make code easier to read. Hope it helps.
private void readFileButton_Click(object sender, EventArgs e)
{
// If you use the stream this way it will be disposed automatically.
using (var sr = new StreamReader(sourceFileString))
{
while (!sr.EndOfStream)
{
string readString = sr.ReadLine();
var flds = readString.Split(',');
string patID = flds[0];
int months = int.Parse(flds[1]);
//I prefer parameters more than fields to communicate between methods.
Random(months);
}
}
}
Random randomGenerator = new Random();
private void Random(int months)
{
randomInteger = randomGenerator.Next(1, months) + 1;
}

In the readFile function, you declare a variable called months and initialize it to the number from your file. This appears correct and probably works great.
However, that variable has function scope. You likely have another variable called "months" at the class level (otherwise you would be getting a compile time error). This variable, and not the one set in "readFile", is what is used by the "Random" method. Change the line to:
months = Convert.ToInt32(flds[1]);
and it will work.
As an aside, you should not use a new instance of Random every time you need a draw. It is considered better practice to have one instance per object and reuse it each time you need a new random number.

Having trouble with moving information

I seem to of hit a bit of a snag in a program I am trying to make for school. I am suppose to make a new class to receive data and get a total to send to a new screen. Well I did the same thing we did in class, but the difference is that that was from a text box and there is no text box for the data I need to move this time, so the way I tried gave me an error. Here is what I got so far:
public StudentSelection()
{
InitializeComponent();
}
public decimal firstCounter;
public decimal secondCounter;
public decimal finalCounter;
struct StudentScores
{
public string StuId;
public decimal TestOne;
public decimal TestTwo;
public decimal Final;
}
StudentScores[] allStudentScores = new StudentScores[10];
// class level array to hold 10 products - read in from a file
private void StudentSelection_Load(object sender, EventArgs e)
{
// read products file into products structure array
try
{
// ALWAYS initialize a structure array before using the array
// before adding, changing, etc.
for (int x = 0; x < 10; x++)
{
allStudentScores[x].StuId = "";
allStudentScores[x].TestOne = 0;
allStudentScores[x].TestTwo = 0;
allStudentScores[x].Final = 0;
}
int arrayIndex = 0; // needed for incrementing index value of the array
// when reading file into array
// now read file into the array after initialization
StreamReader inputFile;
string lineofdata; // used to hold each line of data read in from the file
string[] ProductStringArray = new string[4]; // 6 element string array to hold
// each "field" read from every line in file
inputFile = File.OpenText("StudentScores.txt"); // open for reading
while (!inputFile.EndOfStream) //keep reading until end of file
{
lineofdata = inputFile.ReadLine(); // ReadLine() reads an entire row of data from file
ProductStringArray = lineofdata.Split(','); //each field is separated by ';'
allStudentScores[arrayIndex].StuId = ProductStringArray[0]; // add first element of array to first column of allProducts
allStudentScores[arrayIndex].TestOne = decimal.Parse(ProductStringArray[1]);
firstCounter += allStudentScores[arrayIndex].TestOne;
allStudentScores[arrayIndex].TestTwo = decimal.Parse(ProductStringArray[2]);
secondCounter += allStudentScores[arrayIndex].TestTwo;
allStudentScores[arrayIndex].Final = decimal.Parse(ProductStringArray[3]);
finalCounter += allStudentScores[arrayIndex].Final;
StudentListView.Items.Add(ProductStringArray[0]);
arrayIndex++; // increment so NEXT row is updated with next read
}
//close the file
inputFile.Close();
}
catch (Exception anError)
{
MessageBox.Show(anError.Message);
}
}
private void NextButton_Click(object sender, EventArgs e)
{
decimal firstResult, secondResult, finalResult, stuOne, stuTwo, stuThree;
string stuName;
// call the method in our datatier class
decimal.TryParse(firstCounter, out firstResult);
decimal.TryParse(secondCounter, out secondResult);
decimal.TryParse(finalCounter, out finalResult);
DataTier.AddOurNumbers(firstResult, secondResult, finalResult);
DataTier.StudentData(stuName, stuOne, stuTwo, stuThree);
// now hide this window and display a third window with the total
this.Hide();
// display third window
ScoreScreen aScoreScreen = new ScoreScreen();
aScoreScreen.Show();
}
}
and my new class
class DataTier
{
// public static variable available to all windows
public static decimal firstTotal, secondTotal, finalTotal, stuTestOne, stuTestTwo, stuTestThree;
// static is not associated with any object
public static string stuIDCode;
// create a public method to access from all windows
public static void AddOurNumbers(decimal NumOne, decimal NumTwo, decimal numThree)
{
// devide to get an average
firstTotal = NumOne / 10;
secondTotal = NumTwo / 10;
finalTotal = numThree / 10;
}
public static void StudentData(string name, decimal testOne, decimal testTwo, decimal testThree)
{
stuIDCode = name;
stuTestOne = testOne;
stuTestTwo = testTwo;
stuTestThree = testThree;
}
}
The error is at the three decimal.TryParse parts and I have no clue why it is not working except the error says "cannot convert from decimal to string". Any help will be appreciated.

Change it from:
decimal.TryParse(firstCounter, out firstResult);
decimal.TryParse(secondCounter, out secondResult);
decimal.TryParse(finalCounter, out finalResult);
DataTier.AddOurNumbers(firstResult, secondResult, finalResult);
To:
DataTier.AddOurNumbers(firstCounter, secondCounter, finalCounter);
The problem is that you're trying to call decimal.TryParse(string s, out decimal result) as decimal.TryParse(decimal s, out decimal result).
Your input is already decimal and doesn't require any conversion.
As a side note is that the code
decimal.TryParse(someString, out someOutputDecimal);
without a proper if statement around it will fail silently (it doesn't inform anything about the failure). In fact the output value is set to 0, and it acts as if no faulty input was received. If the input should always be valid, you should use decimal.Parse(someString) instead. However in some cases defaulting to 0 if the input is invalid, can be the desired behavior.

The decimal.TryParse() method takes a string as its first argument and attempts to convert it to a decimal value. In your case, the variables you are passing to TryParse() are already decimal variables and there is no need to parse them. If you want to just copy class variables to local variables, all you need to do is this:
firstResult = firstCounter;
secondResult = secondCounter;
finalResult = finalCounter;
Or in this particular case, you can just pass the class variables directly into AddOurNumbers:
DataTier.AddOurNumbers(firstCounter, secondCounter, finalCounter);
One thing to note here is that value types, such as decimals and other primitives in C# get copied any time you assign them from one value to another, or pass them into a method. This means that even if the value of firstCounter, secondCounter, or thirdCounter changes after calling DataTier.AddOurNumbers(), the values that your data tier has already recieved will not change.