Important Configuration Tags

Creating custom workflow in CRM 2015

This sample shows how to write a custom workflow activity that can create an account and a task for the account. This sample uses early binding.

using System;
using System.Activities;
using System.Collections.ObjectModel;

using Microsoft.Crm.Sdk.Messages;

using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.Messages;
using Microsoft.Xrm.Sdk.Query;
using Microsoft.Xrm.Sdk.Workflow;

namespace Microsoft.Crm.Sdk.Samples
{
	public sealed class SimpleSdkActivity : CodeActivity
	{
		protected override void Execute(CodeActivityContext executionContext)
		{
			//Create the tracing service
			ITracingService tracingService = executionContext.GetExtension<ITracingService>();

			//Create the context
			IWorkflowContext context = executionContext.GetExtension<IWorkflowContext>();
			IOrganizationServiceFactory serviceFactory = executionContext.GetExtension<IOrganizationServiceFactory>();
			IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

			tracingService.Trace("Creating Account");

			Account entity = new Account();
			entity.Name = AccountName.Get<string>(executionContext);
			Guid entityId = service.Create(entity);

			tracingService.Trace("Account created with Id {0}", entityId.ToString());

			tracingService.Trace("Create a task for the account");
			Task newTask = new Task();
			newTask.Subject = TaskSubject.Get<string>(executionContext);
			newTask.RegardingObjectId = new EntityReference(Account.EntityLogicalName, entityId);

			Guid taskId = service.Create(newTask);

			tracingService.Trace("Task has been created");

			tracingService.Trace("Retrieve the task using QueryByAttribute");
			QueryByAttribute query = new QueryByAttribute();
			query.Attributes.AddRange(new string[] { "regardingobjectid" });
			query.ColumnSet = new ColumnSet(new string[] { "subject" });
			query.EntityName = Task.EntityLogicalName;
			query.Values.AddRange(new object[] { entityId });

			tracingService.Trace("Executing the Query for entity {0}", query.EntityName);

			//Execute using a request to test the OOB (XRM) message contracts
			RetrieveMultipleRequest request = new RetrieveMultipleRequest();
			request.Query = query;
			Collection<Entity> entityList = ((RetrieveMultipleResponse)service.Execute(request)).EntityCollection.Entities;

			//Execute a request from the CRM message assembly
			tracingService.Trace("Executing a WhoAmIRequest");
			service.Execute(new WhoAmIRequest());

			if (1 != entityList.Count)
			{
				tracingService.Trace("The entity list was too long");
				throw new InvalidPluginExecutionException("Query did not execute correctly");
			}
			else
			{
				tracingService.Trace("Casting the Task from RetrieveMultiple to strong type");
				Task retrievedTask = (Task)entityList[0];

				if (retrievedTask.ActivityId != taskId)
				{
					throw new InvalidPluginExecutionException("Incorrect task was retrieved");
				}

				tracingService.Trace("Retrieving the entity from IOrganizationService");

				//Retrieve the task using Retrieve
				retrievedTask = (Task)service.Retrieve(Task.EntityLogicalName, retrievedTask.Id, new ColumnSet("subject"));
				if (!string.Equals(newTask.Subject, retrievedTask.Subject, StringComparison.Ordinal))
				{
					throw new InvalidPluginExecutionException("Task's subject did not get retrieved correctly");
				}

				//Update the task
				retrievedTask.Subject = UpdatedTaskSubject.Get<string>(executionContext);
				service.Update(retrievedTask);
			}
		}

		[Input("Account Name")]
		[Default("Test Account: {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> AccountName { get; set; }

		[Input("Task Subject")]
		[Default("Task related to account {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> TaskSubject { get; set; }

		[Input("Updated Task Subject")]
		[Default("UPDATED: Task related to account {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> UpdatedTaskSubject { get; set; }
	}

	public sealed class SdkWithLooselyTypesActivity : CodeActivity
	{
		protected override void Execute(CodeActivityContext executionContext)
		{
			//Create the tracing service
			ITracingService tracingService = executionContext.GetExtension<ITracingService>();

			//Create the context
			IWorkflowContext context = executionContext.GetExtension<IWorkflowContext>();
			IOrganizationServiceFactory serviceFactory = executionContext.GetExtension<IOrganizationServiceFactory>();
			IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

			tracingService.Trace("Creating Account");

			tracingService.Trace("Creating Account");

			Entity entity = new Entity("account");
			entity.Attributes["name"] = AccountName.Get<string>(executionContext);
			Guid entityId = service.Create(entity);

			tracingService.Trace("Account created with Id {0}", entityId.ToString());

			tracingService.Trace("Create a task for the account");
			Entity newTask = new Entity("task");
			newTask["subject"] = TaskSubject.Get<string>(executionContext);
			newTask["regardingobjectid"] = new EntityReference("account", entityId);

			Guid taskId = service.Create(newTask);

			tracingService.Trace("Task has been created");

			Entity updateTask = new Entity("task");
			updateTask.Id = taskId;
			updateTask["subject"] = UpdatedTaskSubject.Get<string>(executionContext);
			service.Update(updateTask);

			tracingService.Trace("Task has been updated");
		}

		[Input("Account Name")]
		[Default("Test Account: {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> AccountName { get; set; }

		[Input("Task Subject")]
		[Default("Task related to account {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> TaskSubject { get; set; }

		[Input("Updated Task Subject")]
		[Default("UPDATED: Task related to account {575A8B41-F8D7-4DCE-B2EA-3FFDE936AB1B}")]
		public InArgument<string> UpdatedTaskSubject { get; set; }
	}

	public sealed class SimpleSdkWithRelatedEntitiesActivity : CodeActivity
	{
		protected override void Execute(CodeActivityContext executionContext)
		{
			//Create the tracing service
			ITracingService tracingService = executionContext.GetExtension<ITracingService>();

			//Create the context
			IWorkflowContext context = executionContext.GetExtension<IWorkflowContext>();
			IOrganizationServiceFactory serviceFactory = executionContext.GetExtension<IOrganizationServiceFactory>();
			IOrganizationService service = serviceFactory.CreateOrganizationService(context.UserId);

			Relationship primaryContactRelationship = new Relationship("account_primary_contact");

			Guid primaryContactId = service.Create(new Contact() { LastName = RootContactLastName.Get<string>(executionContext) });

			//tracingService.Trace("Create an Account with an existing primary contact");
			Account rootAccount = new Account() { Name = RelatedAccountName.Get<string>(executionContext) };
			Contact primaryContact = new Contact()
			{
				EntityState = EntityState.Changed,
				Id = primaryContactId,
				FirstName = RootContactFirstName.Get<string>(executionContext)
			};

			rootAccount.RelatedEntities[primaryContactRelationship] =
				new EntityCollection(new Entity[] { primaryContact }) { EntityName = Contact.EntityLogicalName };

			tracingService.Trace("Execute the Create/Update");
			rootAccount.Id = service.Create(rootAccount);

			//Create the related entities query
			RelationshipQueryCollection retrieveRelatedEntities = new RelationshipQueryCollection();
			retrieveRelatedEntities[primaryContactRelationship] = new QueryExpression(Account.EntityLogicalName)
			{
				ColumnSet = new ColumnSet("name"),
				Criteria = new FilterExpression()
			};

			//Create the request
			RetrieveResponse response = (RetrieveResponse)service.Execute(new RetrieveRequest()
			{
				ColumnSet = new ColumnSet("firstname"),
				RelatedEntitiesQuery = retrieveRelatedEntities,
				Target = new EntityReference(primaryContact.LogicalName, primaryContact.Id)
			});

			tracingService.Trace("Retrieve the record with its related entities");
			Contact retrievedContact = (Contact)response.Entity;
			Account retrievedAccount = (Account)retrievedContact.RelatedEntities[primaryContactRelationship][0];

			tracingService.Trace("Ensure the first name was updated");
			if (retrievedContact.FirstName == primaryContact.FirstName)
			{
				tracingService.Trace("Primary Contact name is correct");
			}
			else
			{
				tracingService.Trace("First Name is \"{0}\", expected \"{1}\".", retrievedContact.FirstName, primaryContact.FirstName);
				throw new InvalidPluginExecutionException("The first name was not changed");
			}
		}

		[Input("Related Account Name")]
		[Default("Related Account")]
		public InArgument<string> RelatedAccountName { get; set; }

		[Input("Root Contact First Name")]
		[Default("New FirstName")]
		public InArgument<string> RootContactFirstName { get; set; }

		[Input("Root Contact Last Name")]
		[Default("Root LastName")]
		public InArgument<string> RootContactLastName { get; set; }
	}
}

	/* Ajax with Un Cached output in MSCRM 4 */
	function _LoadIsvScript(execute) {
	var JsScriptUrl = "/ISV/customscript.js";
	var strServerURL = SERVER_URL.split(ORG_UNIQUE_NAME);
	var script_uri = strServerURL[0] + JsScriptUrl;
	var ajax = new ActiveXObject("Msxml2.XMLHTTP");
	ajax.open('GET', script_uri, false);
	//GetUnCachedVersion
	ajax.setRequestHeader("If-Modified-Since", "Sat, 01 Jan 2000 00:00:00 GMT");
	ajax.setRequestHeader('Cache-Control', 'no-cache');
	ajax.send('');
	return ajax.responseText;
	}

	/* Jscript */
	/* Class in JavaScript */
	var ClassName = (function () {
	// Constructor
	function ClassName(message) {
	this.variable1 = message;
	}
	// Method
	ClassName.prototype.Greeting = function () {
	return "Hello, " + this.variable1;
	};
	return ClassName;
	})();

	/* Once a class is created we can define multiple instance of it and use it to called the defined method.*/

	// this creates an instance of class and assigns it to greeter.
	var g1 = new ClassName("world");

	//this calls the greet function
	g1.Greeting();

	@Echo off
	cls
	@echo --==:{[ WINDOWS SEARCH ]}:==--
	@Echo Searching... [%1]
	dir/b/s %1>search.txt
	@echo SearchCompleted: This will open a text file with results
	msg "SearchCompleted: This will open a text file with results"
	start notepad search.txt

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Reflection;

	namespace killercodes_in
	{
	class Reflector
	{
	const string usage = "prints assembly reflection information over console. \nUsage: Reflector [assmblyName] ...";

	static public void Main(string[] args)
	{
	if ((args.Length == 1 && (args[0] == "?" \|\| args[0] == "/?" \|\| args[0] == "-?" \|\| args[0].ToLower() == "help")))
	{
	Console.WriteLine(usage);
	}
	else
	{
	Assembly assembly = Assembly.LoadFrom(args[0]);
	Reflect(assembly);
	String xml = ReflectXml(assembly);
	//Console.Write(xml);
	}
	}



	/// Exports the reflection information as XML
	static String ReflectXml(Assembly assembly)
	{
	StringBuilder xmlDoc = new StringBuilder();
	Func<string, string, string> tagIt = (tag, value) =>
	{
	return string.Format("<{0}>{1}</{0}>", tag, value);
	};

	xmlDoc.AppendLine(tagIt("assembly", assembly.FullName));
	foreach (string s in assembly.GetManifestResourceNames())
	{
	xmlDoc.AppendLine(tagIt("resource", s));
	}

	foreach (AssemblyName a in assembly.GetReferencedAssemblies())
	{
	xmlDoc.AppendLine(tagIt("references", a.Name));
	}

	foreach (Module m in assembly.GetModules())
	{
	xmlDoc.AppendLine(tagIt("module", m.Name));
	foreach (Type t in m.GetTypes())
	{
	xmlDoc.AppendLine(tagIt("class", t.Name));
	foreach (MethodInfo mtd in t.GetMethods())
	{
	StringBuilder parameters = new StringBuilder();
	foreach (ParameterInfo pra in mtd.GetParameters())
	{
	if (mtd.GetParameters().Count() == 1)
	parameters.Append(pra.ParameterType);
	else
	parameters.Append(pra.ParameterType + ",");
	}

	xmlDoc.AppendLine(tagIt(mtd.MemberType.ToString(), (String.Format("{0} {1}({2}) ", mtd.ReturnParameter.ParameterType.Name, mtd.Name, parameters.ToString()))));
	}
	}
	}

	return xmlDoc.ToString();
	}


	//Prints the Reflection information which includes class, method & parameters
	static void Reflect(Assembly assembly)
	{
	Printer(" Assembly: " + assembly.FullName + "/" + assembly.GetName() + "/" + assembly.EntryPoint);
	foreach (string s in assembly.GetManifestResourceNames())
	{
	Printer(" Resource: " + s);
	}

	foreach (AssemblyName a in assembly.GetReferencedAssemblies())
	{
	Printer(" ReferencedAssembly: " + a.Name);
	}

	foreach (Module m in assembly.GetModules())
	{
	Printer(" Module: " + m);
	foreach (Type t in m.GetTypes())
	{
	Printer(" Class: " + t);
	foreach (MethodInfo mtd in t.GetMethods())
	{
	StringBuilder parameters = new StringBuilder();
	foreach (ParameterInfo pra in mtd.GetParameters())
	{
	if (mtd.GetParameters().Count() == 1)
	parameters.Append(pra.ParameterType);
	else
	parameters.Append(pra.ParameterType + ",");
	}
	PrintMethod(String.Format(" {0}:{1} {2}({3}) ", mtd.MemberType, mtd.ReturnParameter.ParameterType.Name, mtd.Name, parameters.ToString()));
	}
	}
	}
	}

	private static void Printer(String message)
	{
	String[] print = message.Split(':');
	if (print.Count() > 1)
	{
	Console.ForegroundColor = ConsoleColor.Cyan;
	Console.Write(print[0] + ":");
	Console.ForegroundColor = ConsoleColor.White;
	Console.WriteLine(print[1]);
	}
	else
	{
	Console.ForegroundColor = ConsoleColor.White;
	Console.WriteLine(message);
	}

	}

	private static void PrintMethod(String message)
	{
	String[] print = message.Split(':');
	Console.ForegroundColor = ConsoleColor.Cyan;
	Console.Write(print[0] + ": ");
	String[] returnType = print[1].Split(' ');
	Console.ForegroundColor = ConsoleColor.Yellow;
	Console.Write(returnType[0] + " ");
	Console.ForegroundColor = ConsoleColor.Magenta;
	string[] para = (returnType[1]).Split('(');
	Console.Write(para[0]);
	Console.ForegroundColor = ConsoleColor.White;
	Console.WriteLine("(" + para[1]);
	}
	}
	}


	//Synatx Highlight inside Rich Text box
	private void HighLightSyntax()
	{
	//rtbCommand.Enabled = false;
	//rtbCommand.ReadOnly = true;
	//rtbCommand.Cursor = Cursors.No;
	rtbCommand.BorderStyle = BorderStyle.None;


	//Add RichTextBox
	// private System.Windows.Forms.RichTextBox rtbCommand;

	//define the JScript keywords
	string jSkeywords = "abstract\|arguments\|boolean\|break\|byte";

	jSkeywords = jSkeywords.Replace("\|", "\\b\|\\b");

	// create regular Expression
	Regex regExp = new Regex( "\\b" +jSkeywords + "\\b",
	RegexOptions.Compiled \| RegexOptions.Multiline);

	//find all the matches in match collection
	MatchCollection _matches = regExp.Matches(rtbCommand.Text);

	// process all the matched keywords
	foreach (Match match in _matches)
	{
	rtbCommand.Select(match.Index, match.Length);
	rtbCommand.SelectionColor = Color.Red;

	//de-select word and move cursor to the end
	rtbCommand.DeselectAll();
	rtbCommand.SelectionStart = rtbCommand.Text.Length;
	}
	}

	/*It can be called onKeyUp event like
	if(e.KeyCode == Keys.Enter)
	{
	HighLightSyntax();
	}*/

	/* Jscript - event logger */

	// Creates a Eventlog object
	function EvntLog(){
	this.about = "This will log all the messages to system event log on a IE browser";
	}

	// adds functions to it
	EvntLog.prototype = {

	Error:function(ErrorMsg){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(1,Error);
	},
	Success:function(SuccessMessage){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(0,Message);
	},
	Warn:function(WarningMessage){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(2,Message);
	},
	Info:function(InformationMessage){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(4,Information);
	},
	AuditSuccess:function(AuditSuccessMessage){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(8,Message);
	},
	AuditFailure:function(AuditFailureMessage){
	var WshShell = new ActiveXObject("WScript.shell");
	WshShell.LogEvent(16,Message);
	}
	}

	using System;
	using System.IO;
	using System.Net;
	using System.Text;

	public class HttpWebRequestTool
	{
	public static void Main(String[] args)
	{
	if (args.Length < 2)
	{
	Console.WriteLine("Missing argument. Need a URL and a filename");
	}
	else
	{
	StreamWriter sWriter = new StreamWriter(args[1]);
	sWriter.Write(WRequest(args[0], "GET", ""));
	sWriter.Close();
	}
	}


	public static string WRequest(string URL, string method, string postData)
	{
	string responseData = "";
	try
	{
	System.Net.HttpWebRequest hwrequest =
	(System.Net.HttpWebRequest)System.Net.WebRequest.Create(URL);
	hwrequest.Accept = "/";
	hwrequest.AllowAutoRedirect = true;
	hwrequest.UserAgent = "http_requester/0.1";
	hwrequest.Timeout= 60000;
	hwrequest.Method = method;
	if (hwrequest.Method == "POST")
	{
	hwrequest.ContentType = "application/x-www-form-urlencoded";
	// Use UTF8Encoding instead of ASCIIEncoding for XML requests:
	System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
	byte[] postByteArray = encoding.GetBytes(postData);
	hwrequest.ContentLength = postByteArray.Length;
	System.IO.Stream postStream = hwrequest.GetRequestStream();
	postStream.Write(postByteArray, 0, postByteArray.Length);
	postStream.Close();
	}
	System.Net.HttpWebResponse hwresponse =
	(System.Net.HttpWebResponse) hwrequest.GetResponse();
	if (hwresponse.StatusCode == System.Net.HttpStatusCode.OK)
	{
	System.IO.Stream responseStream = hwresponse.GetResponseStream();
	System.IO.StreamReader myStreamReader =
	new System.IO.StreamReader(responseStream);
	responseData = myStreamReader.ReadToEnd();
	}
	hwresponse.Close();
	}
	catch (Exception e)
	{
	responseData = "An error occurred: " + e.Message;
	}
	return responseData;
	}
	}

	using System;

	namespace Killercodes.matrix
	{

	class Program
	{
	static int Counter;
	static Random rand = new Random();

	static int Interval = 100; // Normal Flowing of Matrix Rain
	static int FullFlow = Interval + 30; // Fast Flowing of Matrix Rain
	static int Blacking = FullFlow + 50; // Displaying the Test Alone

	static ConsoleColor NormalColor = ConsoleColor.DarkGreen;
	static ConsoleColor GlowColor = ConsoleColor.Green;
	static ConsoleColor FancyColor = ConsoleColor.White;
	//static String TextInput = "Matrix";

	static char AsciiCharacter//Randomised Inputs
	{
	get
	{
	int t = rand.Next(10);
	if (t <= 2)
	return (char)('0' + rand.Next(10));
	else if (t <= 4)
	return (char)('a' + rand.Next(27));
	else if (t <= 6)
	return (char)('A' + rand.Next(27));
	else
	return (char)(rand.Next(32, 255));
	}
	}
	static void Main()
	{
	Console.ForegroundColor = NormalColor;
	Console.WindowLeft = Console.WindowTop = 0;
	Console.WindowHeight = Console.BufferHeight = Console.LargestWindowHeight;
	Console.WindowWidth = Console.BufferWidth = Console.LargestWindowWidth;
	Console.SetWindowPosition(0, 0);
	Console.CursorVisible = false;

	int width, height;
	int[] y;
	Initialize(out width, out height, out y);//Setting the Starting Point
	while (true)
	{
	Counter = Counter + 1;
	UpdateAllColumns(width, height, y);
	if (Counter > (3 * Interval))
	Counter = 0;

	}
	}
	private static void UpdateAllColumns(int width, int height, int[] y)
	{
	int x;
	if (Counter < Interval)
	{
	for (x = 0; x < width; ++x)
	{
	if (x % 10 == 1)//Randomly setting up the White Position
	Console.ForegroundColor = FancyColor;
	else
	Console.ForegroundColor = GlowColor;
	Console.SetCursorPosition(x, y[x]);
	Console.Write(AsciiCharacter);

	if (x % 10 == 9)
	Console.ForegroundColor = FancyColor;
	else
	Console.ForegroundColor = NormalColor;
	int temp = y[x] - 2;
	Console.SetCursorPosition(x, inScreenYPosition(temp, height));
	Console.Write(AsciiCharacter);

	int temp1 = y[x] - 20;
	Console.SetCursorPosition(x, inScreenYPosition(temp1, height));
	Console.Write(' ');
	y[x] = inScreenYPosition(y[x] + 1, height);

	}
	}
	else if (Counter > Interval && Counter < FullFlow)
	{
	for (x = 0; x < width; ++x)
	{

	Console.SetCursorPosition(x, y[x]);
	if (x % 10 == 9)
	Console.ForegroundColor = FancyColor;
	else
	Console.ForegroundColor = NormalColor;

	Console.Write(AsciiCharacter);//Printing the Character Always at Fixed position

	y[x] = inScreenYPosition(y[x] + 1, height);
	}
	}
	else if (Counter > FullFlow)
	{
	for (x = 0; x < width; ++x)
	{
	Console.SetCursorPosition(x, y[x]);
	Console.Write(' ');//Slowly blacking out the Screen
	int temp1 = y[x] - 20;
	Console.SetCursorPosition(x, inScreenYPosition(temp1, height));
	Console.Write(' ');
	if (Counter > FullFlow && Counter < Blacking)// Clearing the Entire screen to get the Darkness
	{
	if (x % 10 == 9)
	Console.ForegroundColor = FancyColor;
	else
	Console.ForegroundColor = NormalColor;
	int temp = y[x] - 2;
	Console.SetCursorPosition(x, inScreenYPosition(temp, height));
	Console.Write(AsciiCharacter);//The Text is printed Always

	}
	Console.SetCursorPosition(width / 2, height / 2);
	//Console.Write(TextInput);
	y[x] = inScreenYPosition(y[x] + 1, height);
	}

	}
	}
	public static int inScreenYPosition(int yPosition, int height)
	{
	if (yPosition < 0)//When there is negative value
	return yPosition + height;
	else if (yPosition < height)//Normal
	return yPosition;
	else// When y goes out of screen when autoincremented by 1
	return 0;

	}
	private static void Initialize(out int width, out int height, out int[] y)
	{
	height = Console.WindowHeight;
	width = Console.WindowWidth - 1;
	y = new int[width];
	Console.Clear();

	for (int x = 0; x < width; ++x)//Setting the cursor at random at program startup
	{
	y[x] = rand.Next(height);
	}
	}
	}


	}

	public class NeuralNetwork
	{
	public delegate void PrintEventHandler(object message);
	public event PrintEventHandler Cout;
	private int numInput;
	private int numHidden;
	private int numOutput;

	private double[] inputs;
	private double[][] ihWeights; // input-to-hidden
	private double[] ihBiases;
	private double[][] hoWeights; // hidden-to-output
	private double[] hoBiases;
	private double[] outputs;


	public void SelfDemo()
	{
	try
	{
	Console.WriteLine("\nBegin neural network feed-forward demo\n");

	Console.WriteLine("Creating a 3-input, 4-hidden, 2-output neural network");
	Console.WriteLine("Using log-sigmoid function for input-to-hidden and hidden-to-output activation");

	const int numInput = 3;
	const int numHidden = 4;
	const int numOutput = 2;

	NeuralNetwork nn = new NeuralNetwork(numInput, numHidden, numOutput);
	nn.Cout += message => Console.Write("{0}", message);

	const int numWeights = (numInput * numHidden) + (numHidden * numOutput) + numHidden + numOutput; // (34)+(42)+4+2 = 26

	double[] weights = new double[numWeights] {
	0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2,
	-2.0, -6.0, -1.0, -7.0,
	1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0,
	-2.5, -5.0 };

	Console.WriteLine("\nWeights and biases are:");
	nn.ShowVector(weights, 2);

	Console.WriteLine("Loading neural network weights and biases");
	nn.SetWeights(weights);

	Console.WriteLine("\nSetting neural network inputs:");
	double[] xValues = new double[] { 2.0, 3.0, 4.0 };
	nn.ShowVector(xValues, 2);

	Console.WriteLine("Loading inputs and computing outputs\n");
	double[] yValues = nn.ComputeOutputs(xValues);

	Console.WriteLine("\nNeural network outputs are:");
	nn.ShowVector(yValues, 4);

	Console.WriteLine("\nEnd neural network demo\n");
	Console.ReadLine();
	}
	catch (Exception ex)
	{
	Console.WriteLine(ex.Message);
	Console.ReadLine();
	}

	Console.ReadLine();
	}

	public void Write(string format, object[] args)
	{
	string message = string.Format(format, args);
	if (this.Cout != null)
	{
	this.Cout(message);
	}
	}

	public void Write(string message)
	{
	if (this.Cout != null)
	{
	this.Cout(message);
	}
	}

	public NeuralNetwork(int numInput, int numHidden, int numOutput)
	{
	this.numInput = numInput;
	this.numHidden = numHidden;
	this.numOutput = numOutput;

	inputs = new double[numInput];
	ihWeights = MakeMatrix(numInput, numHidden);
	ihBiases = new double[numHidden];
	hoWeights = MakeMatrix(numHidden, numOutput);
	hoBiases = new double[numOutput];
	outputs = new double[numOutput]; // aka hoOutputs
	}

	/*public int numWeights()
	{
	int numWeights = (numInput * numHidden) + (numHidden * numOutput) + numHidden + numOutput; // (34)+(42)+4+2 = 26
	return numWeights;
	}*/

	private static double[][] MakeMatrix(int rows, int cols)
	{
	double[][] result = new double[rows][];
	for (int i = 0; i < rows; ++i)
	result[i] = new double[cols];
	return result;
	}

	public void SetWeights(double[] weights)
	{
	// order: ihWeights (row-col order), ihBiases, hoWeights, hoBiases
	int numWeights = (numInput * numHidden) + (numHidden * numOutput) + numHidden + numOutput;
	if (weights.Length != numWeights)
	throw new Exception("The weights array length: " + weights.Length + " does not match the total number of weights and biases: " + numWeights);

	int k = 0; // points into weights param

	for (int i = 0; i < numInput; ++i)
	for (int j = 0; j < numHidden; ++j)
	ihWeights[i][j] = weights[k++];

	for (int i = 0; i < numHidden; ++i)
	ihBiases[i] = weights[k++];

	for (int i = 0; i < numHidden; ++i)
	for (int j = 0; j < numOutput; ++j)
	hoWeights[i][j] = weights[k++];

	for (int i = 0; i < numOutput; ++i)
	hoBiases[i] = weights[k++];
	}

	public void ShowMatrix(double[][] matrix, int numRows)
	{
	Write("\n");
	int ct = 0;
	if (numRows == -1) numRows = int.MaxValue; // if numRows == -1, show all rows
	for (int i = 0; i < matrix.Length && ct < numRows; ++i)
	{
	for (int j = 0; j < matrix[0].Length; ++j)
	{
	if (matrix[i][j] >= 0.0) Write(" "); // blank space instead of '+' sign
	Write(matrix[i][j].ToString("F2") + " ");
	}
	Write("\n");
	++ct;
	}
	Write("\n");
	}

	public void ShowVector(double[] vector, int decimals)
	{
	Write("\n");
	for (int i = 0; i < vector.Length; ++i)
	{
	if (i > 0 && i % 12 == 0) // max of 12 values per row
	Write("\n");
	if (vector[i] >= 0.0) Console.Write(" ");
	Write(vector[i].ToString("F" + decimals) + " "); // 2 decimals
	}
	Console.WriteLine("\n");
	}

	public double[] ComputeOutputs(double[] xValues)
	{
	if (xValues.Length != numInput)
	throw new Exception("Inputs array length " + inputs.Length + " does not match NN numInput value " + numInput);

	double[] ihSums = new double[this.numHidden]; // these scratch arrays could be class members
	double[] ihOutputs = new double[this.numHidden];
	double[] hoSums = new double[this.numOutput];

	for (int i = 0; i < xValues.Length; ++i) // copy x-values to inputs
	this.inputs[i] = xValues[i];

	//Console.WriteLine("Inputs:");
	//FeedForwardProgram.ShowVector(this.inputs, 2);

	Write("input-to-hidden weights:");
	ShowMatrix(this.ihWeights, -1);

	for (int j = 0; j < numHidden; ++j) // compute input-to-hidden weighted sums
	for (int i = 0; i < numInput; ++i)
	ihSums[j] += this.inputs[i] * ihWeights[i][j];

	Write("input-to-hidden sums before adding i-h biases:");
	ShowVector(ihSums, 2);

	Write("input-to-hidden biases:");
	ShowVector(this.ihBiases, 2);

	for (int i = 0; i < numHidden; ++i) // add biases to input-to-hidden sums
	ihSums[i] += ihBiases[i];

	Write("input-to-hidden sums after adding i-h biases:");
	ShowVector(ihSums, 2);

	for (int i = 0; i < numHidden; ++i) // determine input-to-hidden output
	ihOutputs[i] = LogSigmoid(ihSums[i]);

	Write("input-to-hidden outputs after log-sigmoid activation:");
	ShowVector(ihOutputs, 2);

	Console.WriteLine("hidden-to-output weights:");
	ShowMatrix(hoWeights, -1);

	for (int j = 0; j < numOutput; ++j) // compute hidden-to-output weighted sums
	for (int i = 0; i < numHidden; ++i)
	hoSums[j] += ihOutputs[i] * hoWeights[i][j];

	Write("hidden-to-output sums before adding h-o biases:");
	ShowVector(hoSums, 2);

	Write("hidden-to-output biases:");
	ShowVector(this.hoBiases, 2);

	for (int i = 0; i < numOutput; ++i) // add biases to input-to-hidden sums
	hoSums[i] += hoBiases[i];

	Write("hidden-to-output sums after adding h-o biases:");
	ShowVector(hoSums, 2);

	for (int i = 0; i < numOutput; ++i) // determine hidden-to-output result
	this.outputs[i] = LogSigmoid(hoSums[i]);

	double[] result = new double[numOutput]; // copy hidden-to-output to this.outputs
	this.outputs.CopyTo(result, 0);

	return result;
	} // ComputeOutputs

	private static double LogSigmoid(double z)
	{
	if (z < -20.0) return 0.0;
	else if (z > 20.0) return 1.0;
	else return 1.0 / (1.0 + Math.Exp(-z));
	}

	//extend
	private static int CalculateWeight(int inputNodeCount, int hiddenNodeCount, int outputNodeCount)
	{
	int numWeights = (inputNodeCount * hiddenNodeCount) + (hiddenNodeCount * outputNodeCount) + hiddenNodeCount + outputNodeCount; //count the total weights
	return numWeights;
	}

	} // class

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using System.Diagnostics;

	namespace killercodes_in.ProcKiller
	{
	//Process Killer
	class IProcKiller
	{
	public void I_KillByName(string ProcName)
	{
	try
	{
	Process[] processByName = Process.GetProcessesByName(ProcName);
	//Process pogo = Process.GetProcesses();
	foreach (Process pr in processByName)
	{
	pr.Kill();
	}
	}
	catch
	{
	Console.WriteLine("Cannot terminate " + ProcName + "\n");
	}
	}

	public void I_KillByWinName(string WindowName)
	{
	//bool res;
	try
	{
	Process[] pro = Process.GetProcesses();
	foreach (Process p in pro)
	{
	if (p.MainWindowTitle.Equals(WindowName))
	{
	p.Kill();;
	}

	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using Microsoft.CSharp;
	using System.CodeDom.Compiler;
	using System.Reflection;
	using System.CodeDom;
	using System.IO;

	namespace killercodes_in.CompileOnFly
	{
	public class Compile
	{
	string _codeStatement;
	string _completeCode;

	public Compile(string Code)
	{
	this._codeStatement = Code;
	}

	private string CompleteCode()
	{
	StringBuilder sb = new StringBuilder("using System;");
	sb.AppendLine("namespace killercodes_in.CompileOnFly");
	sb.AppendLine("{");
	sb.AppendLine("public class Program");
	sb.AppendLine("{");
	sb.AppendLine("public static void Main()");
	sb.AppendLine("{").Append(this._codeStatement).Append("}");
	sb.AppendLine("}").AppendLine("}");
	return sb.ToString();
	}

	public bool Execute()
	{
	try
	{
	_completeCode = CompleteCode();

Search

Important Configuration Tags

<authentication>

<authorization>

<compilation>

<customErrors>

<globalization>

<httpRuntime>

<trace>

<identity>

<sessionState>

<appSettings>

Creating custom workflow in CRM 2015

Filtering

Translate

Tag Cloud

Menu

Archive

Popular