Develop Reference

C# Class/Object passing (Array of Objects)

Right so i have a class I'm using to store a set of values
public class dataSet
{
public int Number;
public double Decimal;
public string Text;
//etc...
}
Then I've made an array of type dataSet
public static dataSet[] dataOne = new dataSet[100];
And i'm trying to sort the array of dataOne relevant to the values stored in the int Number stored within dataSet.
I have a sort algorithm ready but i'm struggling to pass in the values stored solely in dataOne.Number so it just ends up being an integer array that i'm passing to the sort.
I'm a total noob at programming so any help would be greatly appreciated.
Edit:
I need to call my sort function by passing it in the array of dataOne.Number if this is possible? So it's basically just passing the sort function an int[]

Give you already have data into your array named dataOne, you could try:
Linq Solution
Use linq to sort it, try this:
dataOne = dataOne.OrderBy(x => x.Number).ToArray();
Remember to add the namespace System.Linq to have access into these methods.
OrderBy allows you to pass an expression to sort data and it will return an IOrderedEnumerable. The ToArray will convert it to an array.
Not Linq Solution
If you are not allowed to use Linq. You could implement an class that implements IComparer<T> and implement the method Compare which takes two generics arguments. Use an instance of this comparer type to sort your data.
For sample, since you have your dataSet type defined, you could implement the comparer:
public class DataSetComparer : IComparer<dataSet>
{
public int Compare(dataSet x, dataSet y)
{
// define the logic to sort here...
return x.Number.CompareTo(y.Number);
}
}
And then, use the comparer on the Array.Sort method:
Array.Sort(dataSet, new NumberComparer());
It will order your dataSets.

I'm not sure I follow why you can't use Linq. But that forces you do to something like this:
var numberValues = new List<int>();
foreach(var dataItem in dataOne)
{
numberValues.Add(dataItem.Number);
}
Then you could pass numberValues.ToArray() to your sort method.
With Linq it would just be
dataOne.Select(d => d.Number).ToArray()

You should have dataset implement IComparable that way you can easily just do...
dataOne = dataOne.OrderBy(x => x).ToArray();
OR...
Array.Sort(dataOne);
Here is how to implement IComparable...
public class dataSet : IComparable
{
public int Number;
public double Decimal;
public string Text;
public int CompareTo(object obj)
{
if (obj == null)
return 1;
dataSet other = obj as dataSet;
if (other != null)
return this.Number.CompareTo(other.Number);
else
throw new ArgumentException("Object is not a dataSet");
}
}

How can I apply an extension method to a datarow column?

I have a datarow filled with ints stored as strings.
I can parse each one like so: Convert.ToInt32(row[1].ToString())
It works, but is a bit unsightly. I got the idea that maybe I could use an extension class to try and make a .ToInt method. Simplifies things a bit. After some research, I wrote this up:
static class DataRowHelper
{
public static int ToInt(this DataRow row)
{
return Convert.ToInt32( row.ToString());
}
}
This almost gets me there, but the problem is that it attaches the new method to the row like this: row.ToInt() instead of of attaching it like this: row[1].ToInt()
What am I missing here?

I feel the other answers are offering solutions, but not answers.
The reason your extension method isn't working is because the return type of the indexer of your DataRow - row[1] isn't a DataRow, it's a string.
You should enhance your extension method to allow for this indexer:
public static class DataRowExtensions
{
public static int ToInt(this DataRow row, int index)
{
return Convert.ToInt32(row[index].ToString());
}
}

You don't have to apply your own extension method to achieve what you're describing in your question, because the MS team already wrote one for you (terrybozzio hinted at it in a comment).
Instead of using syntax like this:
var id = Convert.ToInt32(row[1]);
var id = Convert.ToInt32(row["id"]);
There's a strongly-typed Field extension method that allows you to specify the data type:
var id = row.Field<int>(1);
var id = row.Field<int>("id");
I can't imagine you'll get much shorter or clearer than that by writing your own extension method.

You could just add the column number as a parameter:
int i1 = row.ToInt(1);
int i2 = row.ToInt(2);
etc.
in which case the extension method would be (error handling not included):
public static int ToInt(this DataRow row, int column)
{
return Convert.ToInt32(row[column].ToString());
}

Even better if you want to handle generics and DbNull:
static class DataRowHelper
{
public static int ToInt(this object item)
{
return Convert.ToInt32(item == null ? 0 : item);
}
}
This is not very exception-safe, and will throw on quite a few conditions. You might want to add some checking here, or implement a TryToInt() type method.

Your extension method should inherit a string, not a DataRow. It should look like this (keep in mind this is very simple... and you should probably include error handling of some sort):
static class DataRowHelper
{
public static int ToInt(this string item)
{
return Convert.ToInt32(item);
}
}

Best way to overload a method when all you want to change is the return type

Since return type can't be used to disambiguate methods what is the cleanest/best way to overload a method when all you want to change is the return type? Below is some sample code;
public static string Get(string url, Guid id, bool logResponse = true, bool baseKey = false)
{
Tuple<string, int> response = Get(url, id, true, logResponse, baseKey);
if (response.Item2 > 399)
return null;
return response.Item1;
}
public static Tuple<string, int> Get(string url, Guid id, bool returnStatus, bool logResponse = true, bool baseKey = false)
{
// leaving out lots of code in this method, you should be able to get the point without it
int http_status;
string response = CallApi(url, key, "GET", out http_status);
return new Tuple<string, int>(response, http_status);
}
The above code works however I have an additional param ( returnStatus ) that serves no purpose, it's only there so the compiler can tell the difference between the two methods. Is there a better way to do this or am I just stuck adding useless parameters?

Change name of method, e.g.
string Get(string url, Guid id, bool logResponse)
Tuple<string, int> GetWithStatus(string url, Guid id, bool logResponse)
Main goal of programming is not to tell difference to compiler, but to tell difference to developers which will read your code. Another options is return status as out parameter:
string Get(string url, Guid id, bool logResponse, out int status)
I do not like out parameters very much, but I like tuples even less - what will tell name Item2 to developer which uses your method? Is it status, or retries count, or maybe response length? Neither method name, nor return type cannot say what is it.
So, even for first case with renamed method I'd also changed return type to something like
public class ServerResponse
{
public string Content { get; set; }
public HttpStatusCode Status { get; set; } // enum
// use this in first method to check if request succeed
public bool IsError
{
get { return (int)Status > 399; }
}
}

I see three options.
Return object and disambiguate in your calling method.
Make the method a generic, then detect the desired type using reflection.
Rename the method.
I'd choose #3. Make them "GetOne" and "GetTuple" and you'll be all set.

In my humble opinion, the separation of concerns, if method doing different functions then we separate to two method (different method name).
But I will make one of them is private method for reflection loop, the first method will return generic type of T or just T (I maybe out of topic of Overloading, what I want to say is above example is return string, but for complex object, it can be many Overloading method to return different types, why not just return T, let the caller get object of T).
Overloading is good, depend on requirements.

Interfaces and casting lists

Why doesnt this work, and how to fix?
public interface ITheInterface
{
string a{get;set;}
string b{get;set;}
}
public class SomeObject: ITheInterface
{
string a{get;set;}
string b{get;set;}
...
}
public class SomeGroup
{
ITheInterface Result;
...
}
var results= from y in dc.Groups
where y.id==1
select new SomeGroup
{
Result= (from x in dc.Objects
select new SomeObject{... }
).SingleOrDefault(),
}
return results.ToList();
Could not convert from type System.Collections.Generic.List to Interface

I assume your problem is with the Results.ToList() call? It will fail, because ITheInterface does not support ToList(). You are calling SingleOrDefault() on the LINQ query, which is giving you a single item. It doesn't make sense to call ToList() on a single item.
If, instead, your code read like this:
IEnumerable<SomeObject> Results = from x in dc.Objects
select new SomeObject{... };
Then, Results.ToList() will give you a List<SomeObject>.
If what you are actually looking for is a List<ITheInterface> instead, you can do this:
Results.Cast<ITheInterface>().ToList()

Results is a single object; ToList() only works on Enumerables.
You need to either write return new List { Results }; (this uses a collection initializer) or get rid of the call to SingleOrDefault and declare Results as an IEnumerable<ITheInterface>.
If you only want one object, why are you returning a List?

In addition to the other answers, when you implement an interface, you must declare the member functions as public:
public class SomeObject: ITheInterface
{
public string a{get;set;}
public string b{get;set;}
...
}

You want to say
SomeGroup result = results.SingleOrDefault()
return result;
This is because the return type of your method is SomeGroup (I'm inferring)

LINQ: How to declare IEnumerable[AnonymousType]?

This is my function:
private IEnumerable<string> SeachItem(int[] ItemIds)
{
using (var reader = File.OpenText(Application.StartupPath + #"\temp\A_A.tmp"))
{
var myLine = from line in ReadLines(reader)
where line.Length > 1
let id = int.Parse(line.Split('\t')[1])
where ItemIds.Contains(id)
let m = Regex.Match(line, #"^\d+\t(\d+)\t.+?\t(item\\[^\t]+\.ddj)")
where m.Success == true
select new { Text = line, ItemId = id, Path = m.Groups[2].Value };
return myLine;
}
}
I get a compile error,because "myLine" is not a IEnumerable[string] and I don't know how to write IEnumerable[Anonymous]
"Cannot implicitly convert type 'System.Collections.Generic.IEnumerable[AnonymousType#1]' to 'System.Collections.Generic.IEnumerable[string]'"

You cannot declare IEnumerable<AnonymousType> because the type has no (known) name at build time. So if you want to use this type in a function declaration, make it a normal type. Or just modify your query to return a IENumerable<String> and stick with that type.
Or return IEnumerable<KeyValuePair<Int32, String>> using the following select statement.
select new KeyValuePair<Int32, String>(id, m.Groups[2].Value)

I am not necessarily recommending this...
It is a kind of subversion of the type system but you could do this:
1) change your method signature to return IEnumerable (the non generic one)
2) add a cast by example helper:
public static class Extensions{
public static IEnumerable<T> CastByExample<T>(
this IEnumerable sequence,
T example) where T: class
{
foreach (Object o in sequence)
yield return o as T;
}
}
3) then call the method something like this:
var example = new { Text = "", ItemId = 0, Path = "" };
foreach (var x in SeachItem(ids).CastByExample(example))
{
// now you can access the properties of x
Console.WriteLine("{0},{1},{2}", x.Text, x.ItemId, x.Path);
}
And you are done.
The key to this is the fact that if you create an anonymous type with the same order, types and property names in two places the types will be reused. Knowing this you can use generics to avoid reflection.
Hope this helps
Alex

The method signature on SearchItem indicates that the method returns an IEnumerable<string> but the anonymous type declared in your LINQ query is not of type string. If you want to keep the same method signature, you have to change your query to only select strings. e.g.
return myLine.Select(a => a.Text);
If you insist on returning the data selected by your query, you can return an IEnumerable<object> if you replace your return statement with
return myLine.Cast<object>();
Then you can consume the objects using reflection.
But really, if your going to be consuming an anonymous type outside the method that it is declared in, you should define a class an have the method return an IEnumerable of that class. Anonymous types are convenience but they are subject to abuse.

Your function is trying to return IEnumerable<string>, when the LINQ statement you are executing is actually returning an IEnumerable<T> where T is a compile-time generated type. Anonymous types are not always anonymous, as they take on a specific, concrete type after the code is compiled.
Anonymous types, however, since they are ephemeral until compiled, can only be used within the scope they are created in. To support your needs in the example you provided, I would say the simplest solution is to create a simple entity that stores the results of your query:
public class SearchItemResult
{
public string Text { get; set; }
public int ItemId { get; set; }
public string Path { get; set; }
}
public IEnumerable<SearchItemResult> SearchItem(int[] itemIds)
{
// ...
IEnumerable<SearchItemResult> results = from ... select new SearchItemResult { ... }
}
However, if your ultimate goal is not to retrieve some kind of object, and you are only interested in, say, the Path...then you can still generate an IEnumerable<string>:
IEnumerable<string> lines = from ... select m.Groups[2].Value;
I hope that helps clarify your understanding of LINQ, enumerables, and anonymous types. :)

Return a ValueTuple instead of an anonymous class. Ex (using "named tuples")-
(Text: line, ItemId: id, Path: m.Groups[2].Value)
https://learn.microsoft.com/en-us/dotnet/csharp/tuples
Instead of-
new { Text = line, ItemId = id, Path = m.Groups[2].Value }
The ValueTuple is part of C# version 7 and was originally implemented as a separate NuGet package (System.ValueTuple). Starting with .NET 4.7 it is a built-in type. For .NET Core, versions prior to 2.0 required the NuGet package but it is built-in with version 2.0.

The question was asked a long time ago, I hope it helps someone...
"You cannot declare IEnumerable", instead, must convert it to a "custom" IEnumerable:
public class MyString
{
public string String { get; set; } = string.Empty;
}
public IEnumerable<MyString> GetMyStrings(List<string> Strings)
{
var AnonString = from S in Strings group S by S into Grouped select new { String = Grouped.Key };
IEnumerable<MyString> Result = AnonString.Select(x => new MyString() { String = x.String }).ToArray();
return Result;
}
Regards.

this link could be useful for others who end up here
https://idreesdotnet.blogspot.com/2019/08/c-how-to-create-list-of-anonymous-type.html
the first solution (of 6) is delightlfully simple
1: First create the object(s) of anonymous type and then pass it to an array and call ToList() method.
var o1 = new { Id = 1, Name = "Foo" };
var o2 = new { Id = 2, Name = "Bar" };
var list = new[] { o1, o2 }.ToList();