Develop Reference

How to filter a list using another list in LINQ C#

The list needs to filter is having data like: '1000', '1000A', '1000B', '2000', '2000C', '2003', '2006A'
The list by which I am filtering having data like: '1000', '2000', '2003'
Expected output: 1000', '1000A', '1000B', '2000', '2000C', '2003'
(output is expected like we do in SQL server LIKE operator)

Suppose you are having two class like below,
public class MainClass
{
public string ActualValue { get; set; }
}
public class FilterClass
{
public string Description { get; set; }
}
I am loading some dummy data like this,
List<MainClass> mainList = new List<MainClass>();
mainList.Add(new MainClass() { ActualValue = "1000" });
mainList.Add(new MainClass() { ActualValue = "1000A" });
mainList.Add(new MainClass() { ActualValue = "1002F" });
mainList.Add(new MainClass() { ActualValue = "1002A" });
mainList.Add(new MainClass() { ActualValue = "1003" });
List<FilterClass> filterList = new List<FilterClass>();
filterList.Add(new FilterClass() { Description = "1003" });
filterList.Add(new FilterClass() { Description = "1002" });
The O/P will be given as per your requirement by,
var output1 = mainList.Where(x => filterList.Any(y => x.ActualValue.Contains(y.Description))).ToList();

Try with regex, like this:
var list1 = new List<string>{"1000", "1000A", "1000B","2000","2000A","3000BV"};
var list2 = new List<string>{"1000","2000"};
var result = list1.Where(x => list2.Any(y => Regex.IsMatch(x, $".*{y}.*"))).ToList();
Note: .* are the equivalent of % in SQL.

you could use linq in this way :
var filterList = new List<string>(){"1000", "1000A", "1000B", "2000", "2000C", "2003", "2006A"};
var filterLikeList = new List<string>(){"1000", "2000", "2003"};
var results = filterList.Where(x=> filterLikeList.Any(y=>x.Contains(y)));

Unit test to check for unused properties

I have a function that runs through the properties of a class and replaces the keyword between two dollar signs with the same name from a template.
An example of a class:
public class FeedMessageData : IMailObject
{
public string Username { get; private set;}
public string SubscriptionID { get; private set; }
public string MessageTime { get; private set; }
public string Subject { get; private set; }
public FeedMessageData(string username, string subscriptionID, DateTime messageTime)
{
this.Username = username;
this.SubscriptionID = subscriptionID;
this.MessageTime = messageTime.ToShortDateString();
this.Subject = "Feed " + DateTime.Now + " - SubscriptionID: " + this.SubscriptionID;
}
}
And this is the function to replace the template with the properties:
private string mergeTemplate(string template, IMailObject mailObject)
{
Regex parser = new Regex(#"\$(?:(?<operation>[\w\-\,\.]+) ){0,1}(?<value>[\w\-\,\.]+)\$", RegexOptions.Compiled);
var matches = parser.Matches(template).Cast<Match>().Reverse();
foreach (var match in matches)
{
string operation = match.Groups["operation"].Value;
string value = match.Groups["value"].Value;
var propertyInfo = mailObject.GetType().GetProperty(value);
if (propertyInfo == null)
throw new TillitException(String.Format("Could not find '{0}' in object of type '{1}'.", value, mailObject));
object dataValue = propertyInfo.GetValue(mailObject, null);
template = template.Remove(match.Index, match.Length).Insert(match.Index, dataValue.ToString());
}
return template;
}
I'm looking to create a unit test that writes to the console, possible properties that aren't utilized in the template. An example would be if there wasn't a $SubscriptionID$ in the template. I've tried using PropertyInfo, which gives me the properties of the class, but how do I then use this information to check if they have already been used in the template?

Moq (https://github.com/moq/moq4/wiki) provides ways to verify property/method access.
Follow the tutorials on this link for more details. To verify that your properties are being consumed in your template, you can make use of the VerifyGet method, an example below:
[Fact]
public void VerifyAllPropertiesHaveBeenConsumedInTemplate()
{
var mockMailObject = new Mock<IMailObject>();
var template = "yourTemplateOrMethodThatReturnsYourTemplate";
var result = mergeTemplate(template, mockMailObject.Object);
mockMailObject.VerifyGet(m => m.Username, Times.Once);
mockMailObject.VerifyGet(m => m.SubscriptionID, Times.Once);
mockMailObject.VerifyGet(m => m.MessageTime, Times.Once);
mockMailObject.VerifyGet(m => m.Subject, Times.Once);
}

How to get attribute in C# object like javascript?

There is a function I want to implement in C#:
public string getName(object ob)
{
// TODO: if object has "Name" attribute, return "Name".Value, else return null;
}
When I invoke this function,
string result1 = getName(new {Name = "jack", Age = 12}) // result1 = "jack"
string result2 = getName(new {Age = 12}) // result2 = null
I know it's easy to implement in JavaScript or other dynamic languages... I am curious about if it can implement in C#?

Yes, you can. Take a look to Reflection
public string getName(object ob)
{
var type = ob.GetType();
if (type.GetProperty("Name") == null) return null;
else return type.GetProperty("Name").GetValue(ob, null);
}

There is several ways to achieve that. For example by using reflection. It will take one line code:
public static string GetName(object ob) =>
ob.GetType().GetProperty("Name")?.GetValue(ob)?.ToString();
Or below c#6 way:
public static string GetName(object ob)
{
return ob.GetType().GetProperty("Name")?.GetValue(ob)?.ToString();
}
You can even serialize your object to JSON or XML, then try to get your value from that:
public static string GetName(object obj)
{
string json = JsonConvert.SerializeObject(obj);
string result = JsonConvert.DeserializeAnonymousType(json, new { Name = "" })?.Name;
return result;
}

UPDATE: While this may work for your needs, it is probably not the best solution as pointed out by Grek40, and Damien_The_Unbeliever in comments below due to several limitations.
Not completely deleting the answer as it may give you some information about the alternative despite of its limitations.
Original Answer:
Try this..
Rextester can be found -- http://rextester.com/DQOBW76322
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
namespace Rextester
{
public class Program
{
public static void Main(string[] args)
{
string result1 = getName(new {Name = "jack", Age = 12}); // result1 = "jack"
string result2 = getName(new {Age = 12});
Console.WriteLine(result1);
Console.WriteLine(result2);
}
public static string getName(object obj)
{
var testData = obj.GetType().GetProperties().ToDictionary(p => p.Name, p => p.GetValue(obj).ToString());
if(testData.Any(d => d.Key == "Name")){
return testData["Name"];
}
return null;
}
}
}

Use workflow to evaluate dynamic expression

I would like to pass an object and expression into a dynamically created workflow to mimic the Eval function found in many languages. Can anyone help me out with what I am doing wrong? The code below is a very simple example if taking in a Policy object, multiple its premium by 1.05, then return the result. It throws the exception:
Additional information: The following errors were encountered while processing the workflow tree:
'DynamicActivity': The private implementation of activity '1: DynamicActivity' has the following validation error: Value for a required activity argument 'To' was not supplied.
And the code:
using System.Activities;
using System.Activities.Statements;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
Policy p = new Policy() { Premium = 100, Year = 2016 };
var inputPolicy = new InArgument<Policy>();
var theOutput = new OutArgument<object>();
Activity dynamicWorkflow = new DynamicActivity()
{
Properties =
{
new DynamicActivityProperty
{
Name="Policy",
Type=typeof(InArgument<Policy>),
Value=inputPolicy
}
},
Implementation = () => new Sequence()
{
Activities =
{
new Assign()
{
To = theOutput,
Value=new InArgument<string>() { Expression = "Policy.Premium * 1.05" }
}
}
}
};
WorkflowInvoker.Invoke(dynamicWorkflow);
}
}
public class Policy
{
public int Premium { get; set; }
public int Year { get; set; }
}
}

You can use Workflow Foundation to evaluate expressions, but it is far easier to use almost any other option.
The key issue at play with your code was that you were not trying to evaluate the expression (with either VisualBasicValue or CSharpValue). Assigning InArgument`1.Expression is an attempt to set the value - not to set the value to the result of an expression.
Keep in mind that compiling expressions is fairly slow (>10ms), but the resultant compiled expression can be cached for quick executions.
Using Workflow:
class Program
{
static void Main(string[] args)
{
// this is slow, only do this once per expression
var evaluator = new PolicyExpressionEvaluator("Policy.Premium * 1.05");
// this is fairly fast
var policy1 = new Policy() { Premium = 100, Year = 2016 };
var result1 = evaluator.Evaluate(policy1);
var policy2 = new Policy() { Premium = 150, Year = 2016 };
var result2 = evaluator.Evaluate(policy2);
Console.WriteLine($"Policy 1: {result1}, Policy 2: {result2}");
}
}
public class Policy
{
public double Premium, Year;
}
class PolicyExpressionEvaluator
{
const string
ParamName = "Policy",
ResultName = "result";
public PolicyExpressionEvaluator(string expression)
{
var paramVariable = new Variable<Policy>(ParamName);
var resultVariable = new Variable<double>(ResultName);
var daRoot = new DynamicActivity()
{
Name = "DemoExpressionActivity",
Properties =
{
new DynamicActivityProperty() { Name = ParamName, Type = typeof(InArgument<Policy>) },
new DynamicActivityProperty() { Name = ResultName, Type = typeof(OutArgument<double>) }
},
Implementation = () => new Assign<double>()
{
To = new ArgumentReference<double>() { ArgumentName = ResultName },
Value = new InArgument<double>(new CSharpValue<double>(expression))
}
};
CSharpExpressionTools.CompileExpressions(daRoot, typeof(Policy).Assembly);
this.Activity = daRoot;
}
public DynamicActivity Activity { get; }
public double Evaluate(Policy p)
{
var results = WorkflowInvoker.Invoke(this.Activity,
new Dictionary<string, object>() { { ParamName, p } });
return (double)results[ResultName];
}
}
internal static class CSharpExpressionTools
{
public static void CompileExpressions(DynamicActivity dynamicActivity, params Assembly[] references)
{
// See https://learn.microsoft.com/en-us/dotnet/framework/windows-workflow-foundation/csharp-expressions
string activityName = dynamicActivity.Name;
string activityType = activityName.Split('.').Last() + "_CompiledExpressionRoot";
string activityNamespace = string.Join(".", activityName.Split('.').Reverse().Skip(1).Reverse());
TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings
{
Activity = dynamicActivity,
Language = "C#",
ActivityName = activityType,
ActivityNamespace = activityNamespace,
RootNamespace = null,
GenerateAsPartialClass = false,
AlwaysGenerateSource = true,
ForImplementation = true
};
// add assembly references
TextExpression.SetReferencesForImplementation(dynamicActivity, references.Select(a => (AssemblyReference)a).ToList());
// Compile the C# expression.
var results = new TextExpressionCompiler(settings).Compile();
if (results.HasErrors)
{
throw new Exception("Compilation failed.");
}
// attach compilation result to live activity
var compiledExpression = (ICompiledExpressionRoot)Activator.CreateInstance(results.ResultType, new object[] { dynamicActivity });
CompiledExpressionInvoker.SetCompiledExpressionRootForImplementation(dynamicActivity, compiledExpression);
}
}
Compare to the equivalent Roslyn code - most of which is fluff that is not really needed:
public class PolicyEvaluatorGlobals
{
public Policy Policy { get; }
public PolicyEvaluatorGlobals(Policy p)
{
this.Policy = p;
}
}
internal class PolicyExpressionEvaluator
{
private readonly ScriptRunner<double> EvaluateInternal;
public PolicyExpressionEvaluator(string expression)
{
var usings = new[]
{
"System",
"System.Collections.Generic",
"System.Linq",
"System.Threading.Tasks"
};
var references = AppDomain.CurrentDomain.GetAssemblies()
.Where(a => !a.IsDynamic && !string.IsNullOrWhiteSpace(a.Location))
.ToArray();
var options = ScriptOptions.Default
.AddImports(usings)
.AddReferences(references);
this.EvaluateInternal = CSharpScript.Create<double>(expression, options, globalsType: typeof(PolicyEvaluatorGlobals))
.CreateDelegate();
}
internal double Evaluate(Policy policy)
{
return EvaluateInternal(new PolicyEvaluatorGlobals(policy)).Result;
}
}
Roslyn is fully documented, and has the helpful Scripting API Samples page with examples.

Programmatically generating C# Code Documentation (summary) with CodeDOM

I want to generate C# code documentation with CodeDOM.
Code without Documentation:
public class MyType {
public static BitmapImage File {
get { return GetFile("..."); }
}
}
Code with Documentation:
/// <summary> Gets the File from the location </summary>
public class MyType {
public static BitmapImage File {
get { return GetFile("..."); }
}
}
or
/// <summary>
/// Gets the File from the location
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
public class MyType {
public static BitmapImage File {
get { return GetFile("..."); }
}
}
I'm able to generate the Class, the Member, I can Add some attributes and decorators, But how to generate documentation - unfortunately no.
How I generate the members:
private CodeTypeDeclaration CreateType() {
var classType = new CodeTypeDeclaration("MyType") {
Attributes = MemberAttributes.Public | MemberAttributes.Static
};
var properties = CreateMembers();
classType.Members.AddRange(properties);
return classType;
}
private CodeTypeMember[] CreateMembers() {
var members = _members.Where(x => IsMy(x.Name));
var props = members.Select(CreateProperty).ToArray();
return props;
}
private CodeTypeMember CreateProperty(X x) {
var name = Path.GetFileNameWithoutExtension(x.Name);
var property = new CodeMemberProperty {
Name = name,
HasGet = true,
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Type = new CodeTypeReference(typeof(BitmapImage)),
};
var targetObject = new CodeTypeReferenceExpression(typeof(Y));
var method = Return(new CodeMethodInvokeExpression(targetObject, "Getx", Primitive(x.Name)));
property.GetStatements.Add(method);
return property;
}
private bool IsMy(string path) {
var extension = Path.GetExtension(path.ToLower());
var isMy = Regex.IsMatch(extension, #"\.(jpg)$");
return isMy;
}
Edit:
Add Implementation:
private CodeTypeMember CreateProperty(X x) {
var name = Path.GetFileNameWithoutExtension(x.Name);
var property = new CodeMemberProperty {
Name = name,
HasGet = true,
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Type = new CodeTypeReference(typeof(BitmapImage)),
};
var targetObject = new CodeTypeReferenceExpression(typeof(Y));
var method = Return(new CodeMethodInvokeExpression(targetObject, "Getx", Primitive(x.Name)));
property.GetStatements.Add(method);
//because CodeMemberProperty.Comments is readonly I cast it to CodeTypeMember, which has read/write Comments
var docStart = new CodeCommentStatement("<summary>", true);
var fileSystemName = string.Format("File system Name: {0}", x.Name);
var docContent = new CodeCommentStatement(fileSystemName, true);
var docEnd = new CodeCommentStatement("</summary>", true);
var result = property as CodeTypeMember;
result.Comments.AddRange(new CodeCommentStatementCollection {
docStart,
docContent,
docEnd
});
return result;
}

CodeTypeDeclaration class1 = new CodeTypeDeclaration("Class1");
class1.Comments.Add(new CodeCommentStatement("<summary>", true));
class1.Comments.Add(new CodeCommentStatement("Create a Hello World application.", true));
class1.Comments.Add(new CodeCommentStatement("</summary>", true));
How to: Create an XML Documentation File Using CodeDOM