Temas

Hola amigos, espero todos esten bien, estoy buscando de crear una pequeña app que ejecute esta linea de comandos en powershell

Código [Seleccionar] Expandir

New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\PasswordLess\Device" -Name DevicePasswordLessBuildVersion -Value 0 -Type Dword -Force

Y no tengo ni la mas remota idea de como hacerlo, eh buscado en internet y me eh guiado con ese ejemplo, como resultado este codigo

Código [Seleccionar] Expandir

  PowerShell ps = PowerShell.Create();
            ps.AddCommand(@"New-ItemProperty -Path HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\PasswordLess\Device -Name DevicePasswordLessBuildVersion -Value 0 -Type Dword -Force");
            ps.Invoke();

Pero no funciona y no tengo la mas remota idea de como seria, ya que el ejemplo es muy simple para lo que quiero hacer al parecer.

De antemano gracias .

Hola amigos, estoy perdido con esto, quiero usar una api de una web y no encuentro como hacerlo funcionar, la web es DeepL y luego de registrarme (a medias), me da un ejemplo de como implementarla.

me dice el curl es esto:
curl https://api-free.deepl.com/v2/translate \
   -d auth_key=589f13c6-e0b0-4b74-88bd-ca2ea8669048:fx \
   -d "text=Hello, world!"  \
   -d "target_lang=DE"

Y este es el HTTP Request
POST /v2/translate?auth_key=589f13c6-e0b0-4b74-88bd-ca2ea8669048:fx> HTTP/1.0
Host: api-free.deepl.com
User-Agent: YourApp
Accept: */*
Content-Length: [length]
Content-Type: application/x-www-form-urlencoded

auth_key=589f13c6-e0b0-4b74-88bd-ca2ea8669048:fx&text=Hello, world&target_lang=DE

me puede ayudar para saber como debo usarlo en mi codigo.

Gracias de antemano.

Hola a todos , eh creado una libreria para simular cada tecla precionada, esto funciona bien cuando se trata de una sola tecla, el problema empieza cuando hay que apretar mas de una tecla por ejemplo "ALT+F4" , entiendo que existe una libreria llamada inputsimulator, la cual deje de usar por que de la nada , en mi proyecto empezo a dar un error, donde decia que no tenia permisos para ejecutar dicha acción.

En esta libreria , que dejare debajo para que la puedan analizar, al yo colocar combinaciones de teclas, las ejecuta pero no suelta la primera tecla precionada, ejemplo: "CTRL+C" en este caso lo hace y copia pero , deja apretado la tecla CTRL.

Tampoco preciona la tecla WIN , que es fundamental para una cantidad de atajos en el teclado del sistema, espero puedan ayudarme.

En la libreria, existen dos modos de trabajo, uno que va dirigido a un proceso especifico y otro que va dirigido a la ventana activa.

En el metodo que va dirigido a un proceso se trabaja con esto:
       private const UInt32 WM_KEYDOWN = 0x0100;
            private const UInt32 WM_KEYUP = 0x0101;

y en el metodo que se trabaja con la ventana activa con esto:
           private const int KEYEVENTF_KEYDOWN = 0x0001;
            private const int KEYEVENTF_KEYUP = 0x0002;

espero alguien pueda porfavor explicarme la diferencia, y poder ayudarme a resolver este problema.

De antemano, gracias.

[code] public class Keyboard
        {
            [DllImport("user32.dll")]
            private static extern bool PostMessage(IntPtr hWnd, UInt32 Msg, int wParam, int lParam);
            private const UInt32 WM_KEYDOWN = 0x0100;
            private const UInt32 WM_KEYUP = 0x0101;

            public static void PRESSKEY_ID(int Key, int ID_Process)
            {
                try
                {
                    Process processes = Process.GetProcessById(ID_Process);
                    PostMessage(processes.MainWindowHandle, WM_KEYDOWN, Key, 0);
                    PostMessage(processes.MainWindowHandle, WM_KEYUP, Key, 0);
                }
                catch
                {
                    MessageBox.Show("No es posible ejecutar la acción, el proceso no esta disponible", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }

            }

            public static void KEYUP_ID(int Key, int ID_Process)
            {
                try
                {
                    Process processes = Process.GetProcessById(ID_Process);
                    PostMessage(processes.MainWindowHandle, WM_KEYUP, Key, 0);
                }
                catch
                {
                    MessageBox.Show("No es posible ejecutar la acción, el proceso no esta disponible" , "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }

            }


            public static void KEYDOWN_ID(int Key, int ID_Process)
            {
                try
                {
                    Process processes = Process.GetProcessById(ID_Process);
                    PostMessage(processes.MainWindowHandle, WM_KEYDOWN, Key, 0);
                }
                catch
                {
                    MessageBox.Show("No es posible ejecutar la acción, el proceso no esta disponible", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }

            }

            [DllImport("user32.dll", SetLastError = true)]
            private static extern void keybd_event(byte virtualKey, byte scanCode, uint flags, IntPtr extraInfo);
            private const int KEYEVENTF_KEYDOWN = 0x0001;
            private const int KEYEVENTF_KEYUP = 0x0002;
           
            public static void PRESSKEY(VirtualKeyShort key)
            {
                keybd_event((byte)key, 0, KEYEVENTF_KEYDOWN, IntPtr.Zero);
                keybd_event((byte)key, 0, KEYEVENTF_KEYUP, IntPtr.Zero);
            }

            public static void KEYDOWN(VirtualKeyShort key)
            {
                keybd_event((byte)key, 0, KEYEVENTF_KEYDOWN, IntPtr.Zero);
            }

            public static void KEYUP(VirtualKeyShort key)
            {
                keybd_event((byte)key, 0, KEYEVENTF_KEYUP, IntPtr.Zero);
            }

            public static void KEYSTROKE(VirtualKeyShort key1, VirtualKeyShort key2)
            {
                KEYDOWN(key1);
                PRESSKEY(key2);
                KEYUP(key1);
            }

            public static void KEYSTROKE(VirtualKeyShort key1, VirtualKeyShort key2, VirtualKeyShort key3)
            {
                KEYDOWN(key1);
                KEYDOWN(key2);
                PRESSKEY(key3);
                KEYUP(key2);
                KEYUP(key1);
            }


            public enum VirtualKeyShort : byte
            {
                ///<summary>
                ///Left mouse button
                ///</summary>
                LBUTTON = 0x01,
                ///<summary>
                ///Right mouse button
                ///</summary>
                RBUTTON = 0x02,
                ///<summary>
                ///Control-break processing
                ///</summary>
                CANCEL = 0x03,
                ///<summary>
                ///Middle mouse button (three-button mouse)
                ///</summary>
                MBUTTON = 0x04,
                ///<summary>
                ///Windows 2000/XP: X1 mouse button
                ///</summary>
                XBUTTON1 = 0x05,
                ///<summary>
                ///Windows 2000/XP: X2 mouse button
                ///</summary>
                XBUTTON2 = 0x06,
                ///<summary>
                ///BACKSPACE key
                ///</summary>
                BACK = 0x08,
                ///<summary>
                ///TAB key
                ///</summary>
                TAB = 0x09,
                ///<summary>
                ///CLEAR key
                ///</summary>
                CLEAR = 0x0C,
                ///<summary>
                ///ENTER key
                ///</summary>
                RETURN = 0x0D,
                ///<summary>
                ///SHIFT key
                ///</summary>
                SHIFT = 0x10,
                ///<summary>
                ///CTRL key
                ///</summary>
                CONTROL = 0x11,
                ///<summary>
                ///ALT key
                ///</summary>
                MENU = 0x12,
                ///<summary>
                ///PAUSE key
                ///</summary>
                PAUSE = 0x13,
                ///<summary>
                ///CAPS LOCK key
                ///</summary>
                CAPITAL = 0x14,
                ///<summary>
                ///Input Method Editor (IME) Kana mode
                ///</summary>
                KANA = 0x15,
                ///<summary>
                ///IME Hangul mode
                ///</summary>
                HANGUL = 0x15,
                ///<summary>
                ///IME Junja mode
                ///</summary>
                JUNJA = 0x17,
                ///<summary>
                ///IME final mode
                ///</summary>
                FINAL = 0x18,
                ///<summary>
                ///IME Hanja mode
                ///</summary>
                HANJA = 0x19,
                ///<summary>
                ///IME Kanji mode
                ///</summary>
                KANJI = 0x19,
                ///<summary>
                ///ESC key
                ///</summary>
                ESCAPE = 0x1B,
                ///<summary>
                ///IME convert
                ///</summary>
                CONVERT = 0x1C,
                ///<summary>
                ///IME nonconvert
                ///</summary>
                NONCONVERT = 0x1D,
                ///<summary>
                ///IME accept
                ///</summary>
                ACCEPT = 0x1E,
                ///<summary>
                ///IME mode change request
                ///</summary>
                MODECHANGE = 0x1F,
                ///<summary>
                ///SPACEBAR
                ///</summary>
                SPACE = 0x20,
                ///<summary>
                ///PAGE UP key
                ///</summary>
                PRIOR = 0x21,
                ///<summary>
                ///PAGE DOWN key
                ///</summary>
                NEXT = 0x22,
                ///<summary>
                ///END key
                ///</summary>
                END = 0x23,
                ///<summary>
                ///HOME key
                ///</summary>
                HOME = 0x24,
                ///<summary>
                ///LEFT ARROW key
                ///</summary>
                LEFT = 0x25,
                ///<summary>
                ///UP ARROW key
                ///</summary>
                UP = 0x26,
                ///<summary>
                ///RIGHT ARROW key
                ///</summary>
                RIGHT = 0x27,
                ///<summary>
                ///DOWN ARROW key
                ///</summary>
                DOWN = 0x28,
                ///<summary>
                ///SELECT key
                ///</summary>
                SELECT = 0x29,
                ///<summary>
                ///PRINT key
                ///</summary>
                PRINT = 0x2A,
                ///<summary>
                ///EXECUTE key
                ///</summary>
                EXECUTE = 0x2B,
                ///<summary>
                ///PRINT SCREEN key
                ///</summary>
                SNAPSHOT = 0x2C,
                ///<summary>
                ///INS key
                ///</summary>
                INSERT = 0x2D,
                ///<summary>
                ///DEL key
                ///</summary>
                DELETE = 0x2E,
                ///<summary>
                ///HELP key
                ///</summary>
                HELP = 0x2F,
                ///<summary>
                ///0 key
                ///</summary>
                KEY_0 = 0x30,
                ///<summary>
                ///1 key
                ///</summary>
                KEY_1 = 0x31,
                ///<summary>
                ///2 key
                ///</summary>
                KEY_2 = 0x32,
                ///<summary>
                ///3 key
                ///</summary>
                KEY_3 = 0x33,
                ///<summary>
                ///4 key
                ///</summary>
                KEY_4 = 0x34,
                ///<summary>
                ///5 key
                ///</summary>
                KEY_5 = 0x35,
                ///<summary>
                ///6 key
                ///</summary>
                KEY_6 = 0x36,
                ///<summary>
                ///7 key
                ///</summary>
                KEY_7 = 0x37,
                ///<summary>
                ///8 key
                ///</summary>
                KEY_8 = 0x38,
                ///<summary>
                ///9 key
                ///</summary>
                KEY_9 = 0x39,
                ///<summary>
                ///A key
                ///</summary>
                KEY_A = 0x41,
                ///<summary>
                ///B key
                ///</summary>
                KEY_B = 0x42,
                ///<summary>
                ///C key
                ///</summary>
                KEY_C = 0x43,
                ///<summary>
                ///D key
                ///</summary>
                KEY_D = 0x44,
                ///<summary>
                ///E key
                ///</summary>
                KEY_E = 0x45,
                ///<summary>
                ///F key
                ///</summary>
                KEY_F = 0x46,
                ///<summary>
                ///G key
                ///</summary>
                KEY_G = 0x47,
                ///<summary>
                ///H key
                ///</summary>
                KEY_H = 0x48,
                ///<summary>
                ///I key
                ///</summary>
                KEY_I = 0x49,
                ///<summary>
                ///J key
                ///</summary>
                KEY_J = 0x4A,
                ///<summary>
                ///K key
                ///</summary>
                KEY_K = 0x4B,
                ///<summary>
                ///L key
                ///</summary>
                KEY_L = 0x4C,
                ///<summary>
                ///M key
                ///</summary>
                KEY_M = 0x4D,
                ///<summary>
                ///N key
                ///</summary>
                KEY_N = 0x4E,
                ///<summary>
                ///O key
                ///</summary>
                KEY_O = 0x4F,
                ///<summary>
                ///P key
                ///</summary>
                KEY_P = 0x50,
                ///<summary>
                ///Q key
                ///</summary>
                KEY_Q = 0x51,
                ///<summary>
                ///R key
                ///</summary>
                KEY_R = 0x52,
                ///<summary>
                ///S key
                ///</summary>
                KEY_S = 0x53,
                ///<summary>
                ///T key
                ///</summary>
                KEY_T = 0x54,
                ///<summary>
                ///U key
                ///</summary>
                KEY_U = 0x55,
                ///<summary>
                ///V key
                ///</summary>
                KEY_V = 0x56,
                ///<summary>
                ///W key
                ///</summary>
                KEY_W = 0x57,
                ///<summary>
                ///X key
                ///</summary>
                KEY_X = 0x58,
                ///<summary>
                ///Y key
                ///</summary>
                KEY_Y = 0x59,
                ///<summary>
                ///Z key
                ///</summary>
                KEY_Z = 0x5A,
                ///<summary>
                ///Left Windows key (Microsoft Natural keyboard)
                ///</summary>
                LWIN = 0x5B,
                ///<summary>
                ///Right Windows key (Natural keyboard)
                ///</summary>
                RWIN = 0x5C,
                ///<summary>
                ///Applications key (Natural keyboard)
                ///</summary>
                APPS = 0x5D,
                ///<summary>
                ///Computer Sleep key
                ///</summary>
                SLEEP = 0x5F,
                ///<summary>
                ///Numeric keypad 0 key
                ///</summary>
                NUMPAD0 = 0x60,
                ///<summary>
                ///Numeric keypad 1 key
                ///</summary>
                NUMPAD1 = 0x61,
                ///<summary>
                ///Numeric keypad 2 key
                ///</summary>
                NUMPAD2 = 0x62,
                ///<summary>
                ///Numeric keypad 3 key
                ///</summary>
                NUMPAD3 = 0x63,
                ///<summary>
                ///Numeric keypad 4 key
                ///</summary>
                NUMPAD4 = 0x64,
                ///<summary>
                ///Numeric keypad 5 key
                ///</summary>
                NUMPAD5 = 0x65,
                ///<summary>
                ///Numeric keypad 6 key
                ///</summary>
                NUMPAD6 = 0x66,
                ///<summary>
                ///Numeric keypad 7 key
                ///</summary>
                NUMPAD7 = 0x67,
                ///<summary>
                ///Numeric keypad 8 key
                ///</summary>
                NUMPAD8 = 0x68,
                ///<summary>
                ///Numeric keypad 9 key
                ///</summary>
                NUMPAD9 = 0x69,
                ///<summary>
                ///Multiply key
                ///</summary>
                MULTIPLY = 0x6A,
                ///<summary>
                ///Add key
                ///</summary>
                ADD = 0x6B,
                ///<summary>
                ///Separator key
                ///</summary>
                SEPARATOR = 0x6C,
                ///<summary>
                ///Subtract key
                ///</summary>
                SUBTRACT = 0x6D,
                ///<summary>
                ///Decimal key
                ///</summary>
                DECIMAL = 0x6E,
                ///<summary>
                ///Divide key
                ///</summary>
                DIVIDE = 0x6F,
                ///<summary>
                ///F1 key
                ///</summary>
                F1 = 0x70,
                ///<summary>
                ///F2 key
                ///</summary>
                F2 = 0x71,
                ///<summary>
                ///F3 key
                ///</summary>
                F3 = 0x72,
                ///<summary>
                ///F4 key
                ///</summary>
                F4 = 0x73,
                ///<summary>
                ///F5 key
                ///</summary>
                F5 = 0x74,
                ///<summary>
                ///F6 key
                ///</summary>
                F6 = 0x75,
                ///<summary>
                ///F7 key
                ///</summary>
                F7 = 0x76,
                ///<summary>
                ///F8 key
                ///</summary>
                F8 = 0x77,
                ///<summary>
                ///F9 key
                ///</summary>
                F9 = 0x78,
                ///<summary>
                ///F10 key
                ///</summary>
                F10 = 0x79,
                ///<summary>
                ///F11 key
                ///</summary>
                F11 = 0x7A,
                ///<summary>
                ///F12 key
                ///</summary>
                F12 = 0x7B,
                ///<summary>
                ///F13 key
                ///</summary>
                F13 = 0x7C,
                ///<summary>
                ///F14 key
                ///</summary>
                F14 = 0x7D,
                ///<summary>
                ///F15 key
                ///</summary>
                F15 = 0x7E,
                ///<summary>
                ///F16 key
                ///</summary>
                F16 = 0x7F,
                ///<summary>
                ///F17 key
                ///</summary>
                F17 = 0x80,
                ///<summary>
                ///F18 key
                ///</summary>
                F18 = 0x81,
                ///<summary>
                ///F19 key
                ///</summary>
                F19 = 0x82,
                ///<summary>
                ///F20 key
                ///</summary>
                F20 = 0x83,
                ///<summary>
                ///F21 key
                ///</summary>
                F21 = 0x84,
                ///<summary>
                ///F22 key, (PPC only) Key used to lock device.
                ///</summary>
                F22 = 0x85,
                ///<summary>
                ///F23 key
                ///</summary>
                F23 = 0x86,
                ///<summary>
                ///F24 key
                ///</summary>
                F24 = 0x87,
                ///<summary>
                ///NUM LOCK key
                ///</summary>
                NUMLOCK = 0x90,
                ///<summary>
                ///SCROLL LOCK key
                ///</summary>
                SCROLL = 0x91,
                ///<summary>
                ///Left SHIFT key
                ///</summary>
                LSHIFT = 0xA0,
                ///<summary>
                ///Right SHIFT key
                ///</summary>
                RSHIFT = 0xA1,
                ///<summary>
                ///Left CONTROL key
                ///</summary>
                LCONTROL = 0xA2,
                ///<summary>
                ///Right CONTROL key
                ///</summary>
                RCONTROL = 0xA3,
                ///<summary>
                ///Left MENU key
                ///</summary>
                LMENU = 0xA4,
                ///<summary>
                ///Right MENU key
                ///</summary>
                RMENU = 0xA5,
                ///<summary>
                ///Windows 2000/XP: Browser Back key
                ///</summary>
                BROWSER_BACK = 0xA6,
                ///<summary>
                ///Windows 2000/XP: Browser Forward key
                ///</summary>
                BROWSER_FORWARD = 0xA7,
                ///<summary>
                ///Windows 2000/XP: Browser Refresh key
                ///</summary>
                BROWSER_REFRESH = 0xA8,
                ///<summary>
                ///Windows 2000/XP: Browser Stop key
                ///</summary>
                BROWSER_STOP = 0xA9,
                ///<summary>
                ///Windows 2000/XP: Browser Search key
                ///</summary>
                BROWSER_SEARCH = 0xAA,
                ///<summary>
                ///Windows 2000/XP: Browser Favorites key
                ///</summary>
                BROWSER_FAVORITES = 0xAB,
                ///<summary>
                ///Windows 2000/XP: Browser Start and Home key
                ///</summary>
                BROWSER_HOME = 0xAC,
                ///<summary>
                ///Windows 2000/XP: Volume Mute key
                ///</summary>
                VOLUME_MUTE = 0xAD,
                ///<summary>
                ///Windows 2000/XP: Volume Down key
                ///</summary>
                VOLUME_DOWN = 0xAE,
                ///<summary>
                ///Windows 2000/XP: Volume Up key
                ///</summary>
                VOLUME_UP = 0xAF,
                ///<summary>
                ///Windows 2000/XP: Next Track key
                ///</summary>
                MEDIA_NEXT_TRACK = 0xB0,
                ///<summary>
                ///Windows 2000/XP: Previous Track key
                ///</summary>
                MEDIA_PREV_TRACK = 0xB1,
                ///<summary>
                ///Windows 2000/XP: Stop Media key
                ///</summary>
                MEDIA_STOP = 0xB2,
                ///<summary>
                ///Windows 2000/XP: Play/Pause Media key
                ///</summary>
                MEDIA_PLAY_PAUSE = 0xB3,
                ///<summary>
                ///Windows 2000/XP: Start Mail key
                ///</summary>
                LAUNCH_MAIL = 0xB4,
                ///<summary>
                ///Windows 2000/XP: Select Media key
                ///</summary>
                LAUNCH_MEDIA_SELECT = 0xB5,
                ///<summary>
                ///Windows 2000/XP: Start Application 1 key
                ///</summary>
                LAUNCH_APP1 = 0xB6,
                ///<summary>
                ///Windows 2000/XP: Start Application 2 key
                ///</summary>
                LAUNCH_APP2 = 0xB7,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_1 = 0xBA,
                ///<summary>
                ///Windows 2000/XP: For any country/region, the '+' key
                ///</summary>
                OEM_PLUS = 0xBB,
                ///<summary>
                ///Windows 2000/XP: For any country/region, the ',' key
                ///</summary>
                OEM_COMMA = 0xBC,
                ///<summary>
                ///Windows 2000/XP: For any country/region, the '-' key
                ///</summary>
                OEM_MINUS = 0xBD,
                ///<summary>
                ///Windows 2000/XP: For any country/region, the '.' key
                ///</summary>
                OEM_PERIOD = 0xBE,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_2 = 0xBF,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_3 = 0xC0,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_4 = 0xDB,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_5 = 0xDC,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_6 = 0xDD,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_7 = 0xDE,
                ///<summary>
                ///Used for miscellaneous characters; it can vary by keyboard.
                ///</summary>
                OEM_8 = 0xDF,
                ///<summary>
                ///Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard
                ///</summary>
                OEM_102 = 0xE2,
                ///<summary>
                ///Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key
                ///</summary>
                PROCESSKEY = 0xE5,
                ///<summary>
                ///Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes.
                ///The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information,
                ///see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP
                ///</summary>
                PACKET = 0xE7,
                ///<summary>
                ///Attn key
                ///</summary>
                ATTN = 0xF6,
                ///<summary>
                ///CrSel key
                ///</summary>
                CRSEL = 0xF7,
                ///<summary>
                ///ExSel key
                ///</summary>
                EXSEL = 0xF8,
                ///<summary>
                ///Erase EOF key
                ///</summary>
                EREOF = 0xF9,
                ///<summary>
                ///Play key
                ///</summary>
                PLAY = 0xFA,
                ///<summary>
                ///Zoom key
                ///</summary>
                ZOOM = 0xFB,
                ///<summary>
                ///Reserved
                ///</summary>
                NONAME = 0xFC,
                ///<summary>
                ///PA1 key
                ///</summary>
                PA1 = 0xFD,
                ///<summary>
                ///Clear key
                ///</summary>
                OEM_CLEAR = 0xFE
            }
            internal enum ScanCodeShort : short
            {
                LBUTTON = 0,
                RBUTTON = 0,
                CANCEL = 70,
                MBUTTON = 0,
                XBUTTON1 = 0,
                XBUTTON2 = 0,
                BACK = 14,
                TAB = 15,
                CLEAR = 76,
                RETURN = 28,
                SHIFT = 42,
                CONTROL = 29,
                MENU = 56,
                PAUSE = 0,
                CAPITAL = 58,
                KANA = 0,
                HANGUL = 0,
                JUNJA = 0,
                FINAL = 0,
                HANJA = 0,
                KANJI = 0,
                ESCAPE = 1,
              &nb

Hola amigos, estoy aqui con un problema que no se como resolver, espero alguien pueda ayudarme.

Quiero en un cuadro de texto enviar  textos, la cosa es:
1-No se si estoy usando el control correcto para esto (TextBox) actualmente
2-quiero escribir y que el texto enviado se alinie a la izquierda
3-quiero que cuando envie texto de otro metodo se alinie en el mismo cuadro pero a la derecha

como puedo lograr esto? se que unir el texto al mismo control se hace con Append, mas no se como alinear una los mensajes que envio a mi conveniencia.

Espero puedan darme ayuda , gracias de antemano

Hola a todos, vengo con un problema que no encuentro como hacerlo funcionar, me gustaria mostrar un reporte de un DataTable pero no encuentro como lograrlo, eh investigado por internet y a pesar de encontrar mucha informacion, es muy vieja y los ejemplos y explicaciones que dan no me resultan, les muestro los pasos para mostrar lo que quiero pero no funciona.

1- creo mi formulario en winform, previo a esto instale el nuget: Microsoft.ReportingServices.ReportViewer.WinForms, y agrego mi control reportviewer

2- Creo el Informe (sin asistente) en blanco

3- seteo el informe al control que arrastre

4- agrego este codigo al load del form

Código [Seleccionar] Expandir

             DataSet ds = new DataSet();   ds.Tables.Add(RigorBd.DataGridTablas("Presentacion"));

           reportViewer1.Reset();
           reportViewer1.LocalReport.ReportPath = "Report1.rdlc";
           ReportDataSource rds = new ReportDataSource("T", RigorBd.DataGridTablas("Presentacion"));
           reportViewer1.LocalReport.DataSources.Clear();
           reportViewer1.LocalReport.DataSources.Add(rds);
           reportViewer1.LocalReport.Refresh();

y al ejecutar el informe se muestra en blanco. tal cual como los ejemplos que eh visto, si alguien puede explicarme se lo agradeceria,

NOTA: No uso SQLServer , por eso cargo los datos a mostrar en un DataTablet para poder luego desde ahi mostrarlo en el reporte.

Espero puedan ayudarme

Hola amigos, estoy con un problema , conozco nada de xml y me gustaria saber, como establezco la ruta raiz del proyecto.

en C# seria algo como : Environment.CurrentDirectory , esto establece y te da la ruta raiz del proyecto.

pero no se como seria en XML
ya que lo trato de usar con un nugget llamado Ofuscar.

Gracias de antemano y espero puedan ayudarme.

Hola a todos, estoy en un problema, creo una lista de tipo string, donde guardo los simbolos matematicos, (+) (-) (*) (/), quiero usarlos para que hagan su funcion de acuerdo a lo que pido, pero no encuentro como hacerlo.

actualemnte esta asi

Código [Seleccionar] Expandir

  calculo = calculo + Convert.ToInt32(valores[i]);

pero lo necesito asi

Código [Seleccionar] Expandir

for{ calculo = calculo ListaSimbolo[i] Convert.ToInt32(valores[i]);}
espero puedan ayudarme a resolver este problema

Hola amigos saludos, espero puedan ayudarme, en estos momentos me encuentro con una lucha que no se como resolver, he creado un metodo y quiero que reciba como parametro 
esta funcion

Código [Seleccionar] Expandir

InitializeComponent();

Código [Seleccionar] Expandir

public MainWindow()
        {
            Metodo.Propiol(InitializeComponent());
        }

como ven es el inicializador de la aplicacion en el constructor principal.
no se como hacerlo , si alguien puede ayudarme , se lo agradeceria grandemente.

Hola a todos, chicos les traigo una inquietud, estoy usando la API de mega para descargar y subir archivos, y todo va bien, pero me preguntaba si era posible usar un proxy, entonces empeze a buscar como conectar mi aplicacion a un  proxy o vpn, cosa que tengo duda
1-  es el mismo procedimiento, conectar un proxy o un vpn (usando SoftEtherApi)?
2- la API de MEGA trae su propio conector proxy?
3- si conecto mi aplicacion a algun vpn o proxy ya mi pc tiene esa conexion o se debe establecer algun tipo de adaptador para q la pc tambien tenga acceso a ese proxy o vpn?

espero puedan ayudarme aclarar todas estas dudas.

hola a migos buen dia, hoy les traigo una inquietud y es que no encuentro como hacer funcionar este codigo.

Código [Seleccionar] Expandir

string ruta = Environment.CurrentDirectory + "\\" + "r.rar";
            RarArchive archive = RarArchive.Open(ruta);

            foreach (RarArchiveEntry item in archive.Entries)
            {
                string path = Path.Combine(Path.GetFileName(item.FilePath));
                item.WriteToFile(path);
            }

el error que me arroja es:

System.NullReferenceException: 'Referencia a objeto no establecida como instancia de un objeto.' (Eto ocurre al entrar al foreach en la instancia archive.Entries)

y no eh dado de como solucionarlo, si alguien sabe , espero pueda ayudarme.

PD. gracias de antemano, y en caso de conocer otra api gratuita para descomprimir RAR y de facil uso sin problemas , espero puedan hacerla conocer, gracias.

Buenas noches, les escribo por un problema que no eh podido solucionar, espero puedan ayudarme, estoy utilizando una libreria para bajar videos de youtube, esto esta perfecto, el problema empieza , cuando quiero descargar y en el metodo de descarga, asigno el progress y su correspondiente progressbar pero el valor que carga es minimo , llega al 1% pero en efecto descarga el archivo, probe con una etiqueta y funciono bien , me va marcndo del 0 al 100% pero no me sirve con el progressbar.

Dejo el codigo que tengo hecho

Código [Seleccionar] Expandir

var progressLabel = new Progress<double>(p => lab.Content = $"{p:P0}");
          var progressBarra = new Progress<double>(p => Bar.Value = p);

Espero puedan ayudarme y decirme q hace falta para acomodarlo.
PD: es como si cargara la barra con un valor de 0.00000001 hasta el 1, gracias de antemano.

Hola a todos, paso por aqui con un problemilla que no le encuentro solucion, ocurre que tengo un listobox con una cantidad de datos, que ocurre , al yo seleccionar un elemento por codigo (no haciendo click) usando la propiedad SelectIndex , me selecciona el elemento, si muy bien, el problema radica en que cuando el elemento que selecciono esta fuera de vista por ejemplo es el penultimo yo debo bajar con la barra de scroll para poder verlo seleccionado, lo que necesito y no se hacerlo , es que al ser seleccionado el elemento, la vista del listbox valla de manera automatica y me muestre el elemento seleccionado.

Espero puedan ayudarme y de antemano gracias.

Hola amigos, estoy aprendiendo esto de la red neuronal, y tengo unas dudas , queria saber si alguien con conocimiento me las quita.

1-cuando llamamos entrenamiento a que nos referimos
2-donde se guardan los datos de esa red entrenada para poder ser usada en otros projectos
3-mi pc no cuenta con buena gpu y un procesador no muy sofisticado para que el tiempo de entrenamiento sea mas corto, me hablaron de un tal azure donde lo puedo entrenar , y como bajaria ese resultado de entrenamiento?
4-me baso en un proyecto existente para crear un chatbot [youtube=640,360]https://www.youtube.com/watch?v=MvZahDT2T08[/youtube]
5- cuanto tiempo se deberia entrenar, y aparte de buscar un data set en español, q tipo de material podria usar. (libros, conversasiones de chat)

ESpero puedan ayudarme con estas dudas , ya q este tema por fin empiezo a entenderlo y esta muy interesante
PD.: No se nada de Phyton esta red neuronal esta basada en C#

Hola amigos, espero todos esten bien, les traigo una consulta,  ya que no entiendo la razon del porque ocurre lo siguiente:

Código [Seleccionar] Expandir

string[] files = Directory.GetFiles(@"C:\\", "*.*", SearchOption.AllDirectories);

se supone que con este codigo, deberia obtener un arreglo en teoria, de todos los archivos del equipo ubicadosen el disco "C:\" , eh creado un archivo manifiest en mi proyecto, donde doy permiso de administrador al ejecutar el programa, pero me arroja error, segun po r no tener perimiso para leer archivos de programas, alguien me podria ayudar y explicar, la razon de eso.

De antemano gracias.

P.D: en la carpeta windows me ocurre lo mismo con una carpeta llamada  "CSC".

Hola amigos, hoy por aqui de nuevo , preguntare como puedo cambiar la ruta del archivo user.config que por defecto se guarda en:

Código [Seleccionar] Expandir

C:\Users\[user]\AppData\Local\Microsoft\Example.Settings.CustomCl_Url_3qoqzcgn1lbyw2zx3oz1o3rsw2anyjsn\1.0.0.0

lo que necesito es que me ayuden a cambiar esa ruta por una asignada por mi mismo y que la aplicacion lea esa ruta para cargar dichas configuraciones.

Espero puedan ayudarme. ya que las explicaciones que medio eh visto en internet no me ayudan de a mucho y son poco claras con los codigos q apenas explican.

Hola amigos, hoy traigo una inquietur y espero puedan ayudarme , resulta que practicando esto de programacion, se me ocurrio algo que se ve mucho en programas, y es que en una ventana con un boton, al apretarlo, en vez de abirme la ventana de manera individual aparte, queria que se abriera en la misma ventana de inicio, yo uso WPF y pense en DockPanel, no se si es el mas ideal para esta tarea, en caso de no ser asi espero puedan ayudarme, ya que quiero aprender a abrir ventanas en la misma ventana principal.

Espero entiendan lo que en tratado de explicar, de antemano gracias.

Hola a todos, estoy por aqui hoy por lo siguiente, eh intentado de muchisimas maneras y probado cuanto codigo en internet eh encontrado pero no doy con la solucion, necesito obtener los valores de la siguiente llave, pero siempre me regresa null y no entiendo el porque, ya que eh probado con tras llaves de registro y si me da el valor que tiene.

Anexo el codigo q ocupo para ver quien puede ayudarme con este problema.

Código [Seleccionar] Expandir

   Microsoft.Win32.RegistryKey rkey;
            rkey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\OEMInformation");
            if (rkey == null)
            {
                Console.WriteLine("no");
            }
            else
            {
                string myTestKey = (string)rkey.GetValue("Model");
                Console.WriteLine(myTestKey);
            }

Gracias de antemano

Hola a todos, no sabia como colocarle al post, el asunto es q hice una aplicacion donde al hacer click en un boton se ejecuta el programa, eso esta bien se hace, el problema radica, que al ejecutarse no se abre con los permisos necesarios, a pesar de usar el , "runas" con Verb en el Process q creo de objeto. mas si lo ejecuto desde la carpeta de manera manual, si funciona correctamente, y no entiendo por q ocurre eso si ya tiene permisos de administrador (cosa que no pide al ejecutarlo desde la carpeta de manera manual).

Me ayudarian a determinar por q esa falla?

Hola amigos, estoy por aqui con una intriga q me trae loco, quiero mejorar la interfaz de mi programa, vi videos de un tal Bunifu UI pero al parecer solo funciona con WinForms, luego tengo este otro Material Design UI este aplica a WPF, pero eh seguido los pasos de los videos q eh visto, y eh bajado el proyecto de github mas no se q hacer para poder compilarlo, ya que al abrirlo en el visual studios 2019 da error de carga y no logro compilarlo, alguien sabra como solucionar esto, y conoceran mas alternativas para mejorar la interfaz grafica de la aplicacion??

Hola a todos, en este momento me encuentro con un asunto que no doy como solventarlo, necesito en un listbox, listar archivos, cosa que hace, mas necesito que al final me genere un checkbox con el cual evaluare si quiero o no instalar el programa

anexo el codigo que uso

Código [Seleccionar] Expandir

private void CargaArchivos(string ruta)
       {
          System.Windows.Controls.CheckBox chb = new System.Windows.Controls.CheckBox();
           chb.Content = "Instalar";
           chb.IsChecked = false;
           chb.Foreground = new System.Windows.Media.SolidColorBrush(System.Windows.Media.Colors.Green);
           
           listProgramas.Items.Add(chb);

           string[] ubicacion = Directory.GetFiles(Environment.CurrentDirectory + ruta);
           double f;

           for (int i = 0; i < ubicacion.Length; i++)
           {
               FileVersionInfo info = FileVersionInfo.GetVersionInfo(ubicacion[i]);
               FileInfo file = new FileInfo(ubicacion[i]);

               if (file.Length < 1048576)
               {
                   f = file.Length / 1024;
                   listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + f.ToString() + " Kb" + chb);
                   listProgramas.Items.Add(chb);
               }
               else
               {
                   f = file.Length / 1024;
                   double q = f / 1024;
                   listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + Math.Round(q, 2).ToString() + " Mb" + chb);
                   listProgramas.Items.Add(chb);
               }
               
           }
       }

como ven el puede agregar el combobox al principio, pero luego queda ocupado y salta un error de no poder generarlo de nuevo, por otro lado si comentamos " listProgramas.Items.Add(chb);"

Nos fijamos en esta linea

Código [Seleccionar] Expandir

listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + Math.Round(q, 2).ToString() + " Mb" + chb);
o esta

Código [Seleccionar] Expandir

listProgramas.Items.Add(file.Name + " Version: " + info.FileVersion + " Peso: " + f.ToString() + " Kb" + chb);
y no genera el checkbox, lo coloca como si fuera un .ToString() , alguien sabra como poder solucionar eso?

Hola a todos, realmente estoy lelo con esto y no se como empezar y ni si es posible, quiero crear una aplicacion en wpf donde al apretar un boton se abra una ventana de google y en el cuadro de busqueda automaticamente se escriba "Hola", y luego de manera automatica empiece la busqueda de eso.

No tengo la menor idea de como llenar, buscar el campo a llenar y bueno es algo que me gustaria aprender hacer para aplicarlo a otras webs ideas.

O si es necesario crear en la misma aplicacion un webbrowser con el que busque en la web lo deseado?.

espero puedan ayudarme.

Hola amigos sere breve con mi problema, uso la libreria SevenZipSharp para comprimir y extraer archivos, todo funciona de manera correcta, puedo comprimir y extraer, puedo obtener el progreso de la accion.

El problema radica en que NO puedo cancelar la accion en curso, ocurre que si puedo cancelar el siguiente proceso de compresion o extraccion, mas NO el que ya esta en proceso , podria alguien ayudarme con esto?

Código [Seleccionar] Expandir

SevenZipBase.SetLibraryPath(path);
                       var tmp = new SevenZipCompressor();
                       tmp.ArchiveFormat = OutArchiveFormat.SevenZip;
                       tmp.CompressionMethod = SevenZip.CompressionMethod.Lzma;
                       tmp.CompressionLevel = CompressionLevel.Ultra;
                       tmp.FileCompressionStarted += (s, e) =>
                       {
                           e.Cancel = Cancelar;
                           Dispatcher.Invoke(() =>
                           {
                               des.txtTest.AppendText(String.Format("{0} {1}", e.FileName, Environment.NewLine));
                               des.txtTest.ScrollToEnd();
                           });
                       };
                       tmp.Compressing += (s, e) =>
                       {
                           e.Cancel = Cancelar;
                           Dispatcher.Invoke(() => des.lblPorcentaje.Content = (String.Format("[{0}%]", e.PercentDone)));
                       };
                       tmp.CompressionFinished += (s, e) => Dispatcher.Invoke(() => des.txtTest.AppendText(MultiLenguaje.biblioGra04));
                      tmp.CompressDirectory(folderToZip, destFile);

Este metodo:  tmp.CompressDirectory(folderToZip, destFile) es donde se realiza la accion y no encuentro como hacer que se cancele cuando lo quiero , me obliga a esperar a q termine esa accion para que luego en el siguiente proceso se cancele, (esto ocurre cuando se va a comprimir o extraer a mas de un archivo) pero en caso de ser un unico archivo y quiera cancelar el proceso Nno allo como no puedo.

Espero puedan ayudarme, gracias de antemano.

Hola amigos, tengo una gran pregunta y duda, estoy haciendo un autoclicker (si se que existen muchos por ahi) pero este cumple exigencias particulares, y es que pueda enviar el click  a una aplicacion especifica en segundo plano SIN colocar el raton osea el puntoro real.

el programa en si ya esta... la parte de enviar el click al proceso podria decirse que si, mas no se, como a un proceso especifico, o bueno en este caso la ventana de dicho proceso  se clicke en un punto especifico de dicha ventana, imagino que es el principio de enviar una pulsacion de tecla , el click, eso lo se pero no sabria como empezar con las coordenadas de laventana o mas aun en segundo plano (minimizada).

Gracias de antemano

hola amigos como estan, eh incursionado en esta parte que es el intercanbio de datos de 2 pc, resulta que eh leido sobre sockets y signalR inclinandome a socket que me parecio mas simple de usar aparte de conseguir muchos ejemplos faciles de entender, en este ejemplo que els dejare explica como enviar y recibir datos , mas no dice como puedo hacer que quede abierto y no se cierre luego de recibir el primer dato, alguien me puede ayudar a como mantener la conexion abierta para poder enviar datos  seguidamente ?
teniendo en cuenta que esto no funciona de manera asincronico , probe con esa forma y no pude hacerlo correr por no saber el problema.
aqui funciona de manera no sincronica lo que implica que si lo corro en wpf se frizara la interfaz

Investigando consegui un codigo que me permite enviar string desde el android al pc y es el siguiente codigo

Código [Seleccionar] Expandir

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;

class TcpDemo
{
 static void Main(  )
 {
   new Thread (Server).Start(  );      
   Thread.Sleep (500);              
   Client(  );
 }

 static void Client(  )
 {
   using (TcpClient client = new TcpClient ("localhost", 51111))
   using (NetworkStream n = client.GetStream(  ))
   {
     BinaryWriter w = new BinaryWriter (n);
     w.Write ("Hello");
     w.Flush(  );
     Console.WriteLine (new BinaryReader (n).ReadString(  ));
   }
 }

 static void Server(  )     //
 {
   TcpListener listener = new TcpListener (IPAddress.Any, 51111);
   listener.Start(  );
   using (TcpClient c = listener.AcceptTcpClient(  ))
   using (NetworkStream n = c.GetStream(  ))
   {
     string msg = new BinaryReader (n).ReadString(  );
     BinaryWriter w = new BinaryWriter (n);
     w.Write (msg + " right back!");
     w.Flush(  );                    
   }                                
   listener.Stop(  );
 }
}

muy practico, el problema esta que en wpf puede freezar la pantalla y se cierra al recibir solo un dato hay que volver a ejecutarlo para que vuelva a recibir, esto ultimo quisiera mantenerlo espero puedan ayudarme gracias de antemano

hola amigos en este codigo, puedo enviar una orden a un proceso, el detalle esta en que me trae al frente ese proceso, y necesito que mande la orden pero deje la ventana en segundo plano o no ponerla como ventana activa

Código [Seleccionar] Expandir

[DllImport("User32.dll")]
        static extern int SetForegroundWindow(IntPtr point);

Process p = (Process)listBox.SelectedItem;
                    if (p != null)
                    {
                        IntPtr h = p.MainWindowHandle;
                        SetForegroundWindow(h);
                        simuladorTeclas.Keyboard.KeyPress(VirtualKeyCode.VK_A);
                    }

con ese codigo, envio una pulsacion de tecla a la ventana selecionada en el listbox, y en efecto funciona, el detalle es que trae al frente la ventana de ese proceso, mi idea es que se mantenga en segundo plano y no se convierta en principal o ventana activa.

Hola amigos, tengo un problema al cual no le eh encontrado solucion, poniendole este ejemplo espero puedan entenderme.

Cuando tenemos el WinRAR instalado, podemos hacer click derecho en cualquier archivo (lugar escritorio por ejemplo) , el cual nos desplega un menu cotextual con una serie de opciones, dentro las cuales esta la de ( extraer o descomprimir archivo , segun sea el caso) yo quiero saber como es posible lograr eso, siendo mas especifico, como es posible lograr obtener la ruta completa del archivo para realizar la accion en este caso ( comprimir o descomprimir archivo o carpeta).

Eh entendido anteriormente, que para crear una opcion o boton en el menucontextual es necesario crear una entrada en el registro del windows, cosa ya explicada en el ultimo tema en el cual me asistieron de manera excelente.
Y de momento es un tema ya entendido.

Normalmente uno obtiene la ruta de el archivo o carpeta con un openfiledialog o un browserdialog, el cual nos despliega un menu y es ahi donde seleccionamos el archivo o carpeteta, luego disponer de esa ruta, en mi caso eso no es lo que necesito, en mi caso, necesito obtener la ruta de manera automatica , asi como lo hace el winrar cuando uno selecciona el archivo a comprimir (menu que aparece en el menu contextual al hacer click derecho).

Espero puedan entender mi pregunta y ayudarme feliz dia.

Hola a todos amigos, hoy tengo un problema que no enceuntro nada claro  para solventarlo, tengo un listbox en el cual agrego datos, me gustaria que esa lista de nombres, pueda guardarla en una settings para poder cargarlos de nuevo al iniciar el programa , pero no se como hacerlo, quizas sea algo sencillo y espero puedan ayudarme.

[NEW]Net Ghost v.2.0- Fresh Proxy Scraper & Checker

FEATURES ? Get more than 30,000 new proxies. ? All proxy sources are updated several times a day.

? Proxist export in IP: port format. ? No duplicates - guaranteed. ? Scrape off almost ANY proxy site (even HMA).

? Built-in Proxy Checker. ? Automatic updater: new sources are added every week and the program will update automatically


Net Ghost is the ultimate free solution for all your proxy needs.

If you are looking for a free, simple and easy-to-use program that provides thousands of proxies at the click of a button

and also allow you to see them,

Net Ghost is exactly what you are looking for.

[youtube=640,360]https://youtu.be/8dDU5_z3Mvk[/youtube]

To use the tools must run as admin


Direct Download link 


https://void.cat/b89a999b1853720ff049ca4eaf5b9ea218eb0ab0


https://www.upload.ee/files/8913963/_Cracked__Net_Ghost_v.2.0_Fresh_Proxy_Scraper___Checker.rar.html

[MOD: Links removidos. El software contiene ransomware.]

[Cracked]Vape V3 Leak by ParadiseTeam.



Minecraft Injection Client




LINK

MOD: Links removidos. El software contiene ransomware.

Hola amigos, tengo una inquietud, quiero con la apertura de mi aplicacion agregar opciones al menu contextual de windows, lo cual investigando encontre este ejemplo:

Código [Seleccionar] Expandir

  public partial class MainWindow : Window
    {
        private const string MenuName = "Folder\\shell\\Asistente Virtual AIRH";
        public const string Command = "Folder\\shell\\Asistente Virtual AIRH\\command";

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            cargaContextual();
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            cierreContextual();
        }


        private void cierreContextual()
        {
            try
            {
                RegistryKey reg = Registry.ClassesRoot.OpenSubKey(Command);
                if (reg != null)
                {
                    reg.Close();
                    Registry.ClassesRoot.DeleteSubKey(Command);
                }
                reg = Registry.ClassesRoot.OpenSubKey(MenuName);
                if (reg != null)
                {
                    reg.Close();
                    Registry.ClassesRoot.DeleteSubKey(MenuName);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.ToString());
            }
            finally
            {
            }
        }
       
        private void ejecutrable()
        {
            MessageBox.Show("Hola");
        }
        private void cargaContextual()
        {
            RegistryKey regmenu = null;
            RegistryKey regcmd = null;
            try
            {
                regmenu = Registry.ClassesRoot.CreateSubKey(MenuName);
                if (regmenu != null)
                    regmenu.SetValue("", "AV-AIRH");
                regcmd = Registry.ClassesRoot.CreateSubKey(Command);
                if (regcmd != null)
                    regcmd.SetValue("", @"E:\Descargas\a.exe");

            }
            catch (Exception ex)
            {
                MessageBox.Show(this, ex.ToString());
            }
            finally
            {
                if (regmenu != null)
                    regmenu.Close();
                if (regcmd != null)
                    regcmd.Close();
            }
        }
    }
}

tiene unas pequeñas modificaciones y es funcional, el problema radica en lo siguiente, solo funciona en el menu contextual de carpetas NO archivos , tampoco me deja muy claro, como modificar la accion que se establece al hacer click en el , de momento solo abre el archivo "a.exe" pero quisiera que se ejecutara un metodo especifico que yo establezca, quiero tambien en ves de crear un menu se creen varios , estos varios en un submenu, si alguien me puede guiar se lo agradeceria mucho para poder sacarle partido a ese codigo ejemplo que consegui.

Y como nota final, el poder agregar una imagen a esa opcion de menu contextual, como lo hace el MegaAsync claro ejemplo de lo que quiero hacer.

Buenas tardes , hoy tengo un problema bastante interesante que a mas de uno le gustara saber su solucion (incluyendome), el tema lo inicie con el amigo elektro mas es posible que alguien mas este pasando por lo mismo que yo y quiera saber solucion.

La pregunta inicial fue la siguiente:

Eh usado el cancellinToken para cancelar una Task, y resulta bien (ya que antes debia cerrar y abrir la aplicacion para cancelar tal accion) el problema esta en que al llamar de nuevo la Task, NO ocurre nada, me gustaria saber como puedo "reiniciar" o una vez cancelada la Task pueda reutilizarla y no quede inutil, ya que para que funcione de nuevo debo cerrar y abrir la aplicacion nuevamente...

La respuesta dada por Elektro fue la siguiente:

Hola. No se a que te refieres por "cancellinToken" pero no existe ningún miembro que se llame así en .NET Framework y que esté relacionado con la clase Task, por ende intuyo que probablemente en realidad quisiste decir la clase "CancellationToken" o bien ese "cancellinToken" al que te referiste sea un miembro que está definido en el código fuente de la librería de terceros que estés utilizando...

Respondiendo a tu duda principal, la clase Task representa una "tarea" en segundo plano (un thread) que transiciona de un estado inicial de creación a un estado final de terminación, esto significa que la tarea solo se puede iniciar una vez, y cualquier intento de volver a iniciar una tarea que no esté en el estado inicial de creación dará como resultado una excepción.

Lo que debes hacer, es crear una nueva instancia de ese objeto Task cuando se haya finalizado, y entonces ya puedes volver a iniciar. Te muestro un ejemplo:

Código [Seleccionar] Expandir

    Action action = new Action(() => Console.WriteLine("Hello Asynchronic World!"));
     
    Task t = new Task(action);
    t.Start();
    t.Wait();
    t.Dispose();
     
    t = new Task(action);
    t.Start();
    t.Wait();
    t.Dispose();

PD: en la mayoría de casos no debes preocuparte por llamar al método Task.Dispose(), las razones se explican aquí (en la sección Remarks):

    https://msdn.microsoft.com/en-us/library/dd270681(v=vs.110).aspx

mostre la linea de codigo al cual quiero aplicar el token y en efecto como dijo elktro puedo llamarlo cuantas veces quiera mas no funciona una vez cancelado por el token la tarea.

En el código que has mostrado no hay necesidad de "reiniciar" el método 'videoDescarga', puedes llamar a dicho método cuantas veces quieras de forma consecutiva, el problema que creo debes estar teniendo es con el token de cancelación, ¿verdad?. Para simplificarlo, imagina que un token de cancelación representa estados... más o menos como una Task, el estado cancelado y el de no cancelado, y una vez cancelado no puedes volver a cancelarlo, no puedes volver a usarlo, así que debes asegurarte de renovar el token de cancelación cuando este se haya cancelado, asegúrate de hacer eso, si el token es cancelado entonces debes crear una nueva instancia de la clase CancellationTokenSource y de la clase CancellationToken para pasarle el nuevo token al método 'videoDescarga'.

Continuando con el tema, de mi problema a pesar que me han dicho que debo crear  un New token no se como hacerlo al cancelarlo, como podria hacerlo ?

el metodo de cancelacion lo tengo de la siguiente manera:

Código [Seleccionar] Expandir

public static void cerrarVideo()
                {
                    cancellationTokenSource.Cancel();
                }

Espero puedan ayudarme con esto, ya que me tiene dando vueltas la cabeza desde hace ya un rato. Gracias !

hola a todos, espero puedan ayudarme en este problema.

estoy usando la api MegaApiCLient
y aunque todo va casi bien en este codigo , no veo lo que hago mal

Código [Seleccionar] Expandir

   static void descargaMegaFile()
        {           
                var client = new MegaApiClient();
                client.LoginAnonymous();

                Uri fileLink = new Uri("https://mega.nz/#!4YlxhLpD!i0RpF63RTLkjvHvHoeqf3xm8yXQv0zDzp954XtouMUE");
                INodeInfo node = client.GetNodeFromLink(fileLink);

                Console.WriteLine($"Downloading {node.Name}");
                Progress<double> ze = new Progress<double>(p => Console.WriteLine($"Progress updated: {p:P0}"));
                client.DownloadFileAsync(fileLink, node.Name, ze);

                client.Logout();
            Console.ReadKey();
        }

en teoria esta bien pero al iniciar la descarga da un error.

en cambio este esta perfecto mas no puedo capturar el progress de la descarga

Código [Seleccionar] Expandir

   static void descargaMegaFile()
        {           
                var client = new MegaApiClient();
                client.LoginAnonymous();

                Uri fileLink = new Uri("https://mega.nz/#!4YlxhLpD!i0RpF63RTLkjvHvHoeqf3xm8yXQv0zDzp954XtouMUE");
                INodeInfo node = client.GetNodeFromLink(fileLink);

                Console.WriteLine($"Downloading {node.Name}");
               
                client.DownloadFile(fileLink, node.Name);

                client.Logout();
            Console.ReadKey();
        }

si alguien tiene conocimiento espero pueda ayudarme

Buenas noches a todos, espero esten bien , hoy tengo un problema y me gustaria saber como poder resolverlo, esta api la utilizo para enviar archivos del pc a el telegram, el problema radica , que cuando envio el archivo llega sin nombre ni extension, solo dice "Document" y esto no eh podido cambiarlo a pesar que eh revisado "Todo".

Código [Seleccionar] Expandir

               Telegram.Bot.Types.InputFiles.InputOnlineFile f = new Telegram.Bot.Types.InputFiles.InputOnlineFile(System.IO.File.Open(s[i], FileMode.Open));

BibliotecaMetodos.Bot.SendDocumentAsync(idTelegram, f.Content, "Guardar como: " + "Nombre Archivo");                  


Explico un poco, el f.Content es la variable (no se si es el termino correcto porfavor corrijanme) que indica cual es el archivo solo que dice que el "protected set - esta protegido" y no encuentro como cambiar tal cosa por mas que he buscado.

Si alguien sabe como dar el nombre por defecto del archivo en este caso el documento enviado se lo agradeceria mucho.

el "Guardar como" solo da un mensaje adjunto al archivo mas nada.

https://github.com/TelegramBots/Telegram.Bot Anexo el api usado la url

PD. eh llegado a pensar que la api no permite tal modificacion siendo esa su limitante

Anexo esto, donde en teroia esta bien mas no hace lo que debe

Código [Seleccionar] Expandir

string fileName = Path.GetFileName(s[i]);
                Telegram.Bot.Types.InputFiles.InputOnlineFile f = new Telegram.Bot.Types.InputFiles.InputOnlineFile(System.IO.File.Open(s[i], FileMode.Open), fileName);
               
                if (Path.GetExtension(s[i]) == ".doc" || Path.GetExtension(s[i]) == ".docx" || Path.GetExtension(s[i]) == ".rtf" || Path.GetExtension(s[i]) == ".pdf")
                {
                    BibliotecaMetodos.Bot.SendDocumentAsync(Settings.Default.idTelegram, f.Content, "Guardar como: " + Path.GetFileName(s[i]));
                }

Buenas gente, justo uso esa libreria (del titulo) para obtener la temperatura del procesador y la tarjeta grafica, pero me di cuenta que es posible obtener datos como cantidad de memoria usada total y libre de la ram y tambien los mismos datos del disco duro, mas no se como lograr esos ultimos, podrian ayudarme con ello? anexo el codigo con el que consigo los datos de temperatura.

Código [Seleccionar] Expandir

public static void GetSystemInfo()
               {
                   TempProcesador updateVisitor = new TempProcesador();
                   Computer computer = new Computer();
                   computer.Open();
                   computer.CPUEnabled = true;
                   computer.GPUEnabled = true;
                   computer.Accept(updateVisitor);
                   for (int i = 0; i < computer.Hardware.Length; i++)
                   {
                       if (computer.Hardware[i].HardwareType == HardwareType.CPU)
                       {
                           for (int j = 0; j < computer.Hardware[i].Sensors.Length; j++)
                           {
                               if (computer.Hardware[i].Sensors[j].SensorType == SensorType.Temperature)
                                   
                                   BibliotecaMetodos.de.SendTextMessageAsync(Settings.Default.ed, $@"Temperatura de procesador
{computer.Hardware[i].Sensors[j].Name}: {computer.Hardware[i].Sensors[j].Value.ToString()}");
                           }
                       }
                       if (computer.Hardware[i].HardwareType == HardwareType.GpuNvidia || computer.Hardware[i].HardwareType == HardwareType.GpuAti)
                       {
                           for (int j = 0; j < computer.Hardware[i].Sensors.Length; j++)
                           {
                               if (computer.Hardware[i].Sensors[j].SensorType == SensorType.Temperature)
                               {
                                   BibliotecaMetodos.de.SendTextMessageAsync(Settings.Default.ed, $@"Temperatura GPU
{computer.Hardware[i].Sensors[j].Name}: {computer.Hardware[i].Sensors[j].Value.ToString()} ºC");
                               }
                           }
                       }
                   }
                   computer.Close();
               }
           }

es totalmente funcional, si alguien ya ha usado esa libreria seria fantastico que me ayudara con el codigo para la obtencion de esos datos.

Buenas noches amigos, aqui les traigo un problema que no le encuentro solucion aun, tengo un codigo para poder enviar archivos de diferentes formatos a una cuenta de telegram, todo esta bien , el problema es que llegan los archivos PERO sin nombre, me explico segui "todo" como debe ser. y al enviarlo en caso de un documento, envia el archivo con el nombre "Document" y sin extension de paso.

Espero puedan ayudarme con la solucion a esto y poder enviar el archivo con su nombre y extension y asi llegue al otro lado. anexo el codigo funcional expetuando eso.

Código [Seleccionar] Expandir

Telegram.Bot.Types.InputFiles.InputTelegramFile f = new Telegram.Bot.Types.InputFiles.InputTelegramFile(System.IO.File.Open(ofd.FileName, FileMode.Open));
                               
                                if (Path.GetExtension(ofd.FileName) == ".doc" || Path.GetExtension(ofd.FileName) == ".docx" || Path.GetExtension(ofd.FileName) == ".rtf" || Path.GetExtension(ofd.FileName) == ".pdf")
                                {
                                    Biblioteca.Herramientas.TelegramTool.Bot.SendDocumentAsync(Settings.Default.idTelegram, f.Content, f.FileName = ofd.SafeFileName);
                                }
                                else if (Path.GetExtension(ofd.FileName) == ".jpg" || Path.GetExtension(ofd.FileName) == ".jpge" || Path.GetExtension(ofd.FileName) == ".png" || Path.GetExtension(ofd.FileName) == ".bmp")
                                {
                                    Biblioteca.Herramientas.TelegramTool.Bot.SendPhotoAsync(Settings.Default.idTelegram, f.Content, f.FileName = ofd.SafeFileName);
                                }
                                else if (Path.GetExtension(ofd.FileName) == ".mp3" || Path.GetExtension(ofd.FileName) == ".mp2" || Path.GetExtension(ofd.FileName) == ".wav")
                                {
                                    Biblioteca.Herramientas.TelegramTool.Bot.SendAudioAsync(Settings.Default.idTelegram, f.Content, f.FileName = ofd.SafeFileName);
                                }
                                else if (Path.GetExtension(ofd.FileName) == ".mp4" || Path.GetExtension(ofd.FileName) == ".3gp" || Path.GetExtension(ofd.FileName) == ".avi" || Path.GetExtension(ofd.FileName) == ".mkv")
                                {
                                    Biblioteca.Herramientas.TelegramTool.Bot.SendVideoAsync(Settings.Default.idTelegram, f.Content);
                                }                 

Esta en un simple boton, gracias de antemano , espero sua tencion y ayuda.
Anexo, la informacion que encontre en internet esta desactualizada respecto al que descargue (al parecer la ultima version), pueden fijarse en los planteamientos diferentes que hay y el mio.

Hola , a todos, esta noche les traigo un problema que no puedo resolver, eh conseguido un codigo para lo que necesito pero en otro leguanje que no es wpf, el lenguaje es VB aunque no estoy seguro y me da el error siguiente el cual no puedo resolver.

"No se puede convertir un objeto de tipo string al tipo diagnostic.process"

y aqui el codigo

Código [Seleccionar] Expandir

 Process p = (Process) listBox1.SelectedItem;
                   if (p != null)
                   {
                       IntPtr h = p.MainWindowHandle;
                       SetForegroundWindow(h);
                       simuladorTeclas.Keyboard.KeyPress(VirtualKeyCode.VK_A);
                   }
Esto consiste en seleccionar de un listbox un proceso y a ese proceso enviar la accion, que en este caso seria precionar la tecla "a"

Me podrian ayudar con el codigo que no allo como hacer para que me funcione y es creo , lo ultimo para que sirva, de antemano gracias.

Anexo, que el codigo de donde me estoy guiando funciona perfectamente

Código [Seleccionar] Expandir

  Process p = (Process) listBox1.SelectedItem;
                    if (p != null)
                    {
                        IntPtr h = p.MainWindowHandle;
                        SetForegroundWindow(h);
                        simuladorTeclas.Keyboard.KeyPress(VirtualKeyCode.VK_A);
                    }
ejecutando esto desde un boton que es lo original

Buenas noches amigos, hoy les traigo una consulta con la cual no eh dado respuesta por ningun lado y espero ustedes puedan ayudarme, mi proyecto al iniciar abre dos "ventanas" puedo manipular una , y la otra es una"alerta" para el usuario, el problema empieza que cuando apreto (alt+tab) , en ese menu (no se como se llama) se muestra todo lo que esta activo , incluyendo la "ventana de alerta" mi pregunt es.

Existe alguna manera para ocultar una ventana especifica del proyecto al apretar (alt+tab) ? y si es asi, como seria la forma.

Muchas Gracias .!

Hola amigos, hoy les traigo una inquietud y consulta , actualmente uso la libreria SevenZip para comprimir y descomprimir archivos, eh realizado trabajos interesantes con ella y me han quedado bien (comprimir / descomprimir), ahora tengo una inquietud y es, que al descomprimir archivos con contraseña me da un error, lo que necesito es saber , como puedo validar un archivo que, en caso de tener contraseña lo compare con un textbox y en caso de no tener contraseña seguir su proceso normal como ya lo hace.

mi codigo actual esta asi

Código (csharp) [Seleccionar] Expandir

public void metodoExtraccion()
       {
           AvisoDescargas des = new AvisoDescargas();
           des.listaDescargas.Visibility = System.Windows.Visibility.Visible;
           des.lblDescargaTitulo.Content = "EXTRAYENDO ARCHIVOS";
           des.Show();

           Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog
           {
               Title = "Archivos a Descomprimir",
               Filter = "Extraer (7z RAR Zip ISO|*.7z; *.rar; *.zip; *.iso",
               Multiselect = true
           };
           if ((ofd.ShowDialog() == true))
           {
               StreamWriter sw = new StreamWriter("listfile.lst");
               foreach (string n in ofd.FileNames)
               {
                   sw.WriteLine(n);
               }
               sw.Close();

               string zipName = ofd.FileName;

               System.Threading.Tasks.Task.Run(() => {
                   using (var tmp = new SevenZipExtractor(
                       
                   File.OpenRead(zipName)))
                   {
                       
                       tmp.FileExtractionStarted += (s, e) =>
                       {
                           Dispatcher.Invoke(() => des.listaDescargas.Items.Add((String.Format("Extrayendo... [{0}%] {1}", e.PercentDone, e.FileInfo.FileName))));
                           
                       };
                       tmp.ExtractionFinished += (s, e) => { Dispatcher.Invoke(() => des.listaDescargas.Items.Add("Proceso Finalizado")); };
                       try
                       {
                           Directory.CreateDirectory(ofd.SafeFileName);
                           string nombre = Path.GetFileNameWithoutExtension(ofd.SafeFileName);
                           string salida = Path.Combine(Settings.Default.directorioExtraidos, nombre);
                           tmp.ExtractArchive(salida);
                           MainWindow.habla.SpeakAsync("Extraccion Finalizada");
                           Directory.Delete(ofd.SafeFileName, true);
                       }
                       catch (Exception)
                       {
                           des.lblPorcentaje.Content = "Necesita Contraseña";
                           MainWindow.habla.Speak("No se puede extraer, archivo dañado o con contraseña");
                       }
                       
                   }
               });
           };
       }

El codigo es totalmente funcional, espero puedan ayudarme con un ejemplo con validacion de contraseña y de ahi partir a adaptarlo a mi codigo , gracias de antemano.

Buenas noches amigos, estoy con una consulta y espero puedan ayudarme como en ocasiones anteriores, que mas que eso han sido respuestas con un gran valir educativo.

El asunto es el siguiente, usando el programa ffmpeg eh hecho muchas cosas y en este caso el poder capturar el sonido del microfono y la pantalla del escritorio en un video.
Este codigo es totalmente funcional, el unico detalle es que el video va a una velocidad muy rapida no acorde a la voz del microfono asi que no se reproduce como debe ser se corta antes de  tiempo, eh buscado mucho y no eh encontrado nada relacionado a eso, espero alguien pueda ayudarme.

Código [Seleccionar] Expandir


    string input = "salida";
            string audio = Settings.Default.micDefault;
            string destFile = Path.Combine(Settings.Default.directorioVideo, Path.GetFileNameWithoutExtension(input) + ".mp4");
            string args = string.Format(@"-y -rtbufsize 200M -f gdigrab -thread_queue_size 1024 -probesize 10M -r 30 -draw_mouse 1 -i desktop -f dshow -channel_layout stereo -thread_queue_size 1024 -i audio=""{0}"" -c:v libx264 -r 30 -preset ultrafast -tune zerolatency -crf 25 -pix_fmt yuv420p -c:a aac -strict -2 -ac 2 -b:a 128k  ""{1}", audio, destFile);

            System.Threading.Tasks.Task.Run(() =>
            {
                System.Diagnostics.Process Conversor = new System.Diagnostics.Process();
                Conversor.StartInfo.FileName = "ffmpeg";
                Conversor.StartInfo.Arguments = args;
                Conversor.Start();
                Conversor.WaitForExit();
                Conversor.Close();
            });


Nota: Como un extra , si alguien sabe como bajar el peso del archivo seria fantastico ya que con solo 2 segundos ya son 2 Mb aproximadamente... (muy alto).

Nota 2 : La  Settings.Default.micDefault; es donde se guarda un microfono (nombre exactamente)

Settings.Default.directorioVideo; Ruta de salida odnde se guarda el archivo.

Muchas Gracias

Hola muchachos, tengo un pequeño problema y es que en c# no logro colocar en la linea de argumentos las dobles comillas " " para archivos con espacio, me explico mejor.

esta es la linea para convertir archivos : "ffmpeg -i entrada.mp4 salida.mp3"

Pero cuando intento esto "ffmpeg -i entrada dos.mp4 salida.mp3" me genera un error el cual para corregirlo debo colocar, "ffmpeg -i "entrada dos.mp4" salida.mp3" y me convierte el archivo todo esto desde una ventana de "Dos".

El problema es que en C# , wpf no encuentro para hacer esta linea "ffmpeg -i "entrada dos.mp4" salida.mp3"

el codigo esta en un boton(openfiledialog)

Código [Seleccionar] Expandir


                string entrada = "\"" + ofd.FileName + "\"";

                    System.Diagnostics.Process Conversor = new System.Diagnostics.Process();
                    Conversor.StartInfo.FileName = "ffmpeg";
                    Conversor.StartInfo.Arguments = $"-i {entrada} -b:a 320k {@"C:\"}";
                    Conversor.Start();
                    Conversor.WaitForExit();           
                    Conversor.Close();


es funcional para archivos sin espacio, espero puedan ayudarme

Buenas noches amigos, eh estado trabajando con la libreria SevenZip y me ah resultado tremenda, cree mi proyecto para probar el codigo aparte y me funciono de maravilla pero a la hora de aplicarlo a mi codigo base me da un error que no le encuentro razon de ser y me gustaria otras opiniones.

Este es el codigo de mi proyecto independiente.

Código (csharp) [Seleccionar] Expandir


public void sevenZipCompresorD()
       {
           System.Threading.Tasks.Task.Run(() =>
           {
               System.Windows.Forms.FolderBrowserDialog ofd = new System.Windows.Forms.FolderBrowserDialog();
               ofd.Description = "Seleccione la carpeta a comprimir";
               ofd.RootFolder = Environment.SpecialFolder.Desktop;

               Dispatcher.Invoke(() =>
               {

                   if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                   {
                       string folderToZip = ofd.SelectedPath;

                       System.Threading.Tasks.Task.Run(() =>
                       {
                           var tmp = new SevenZipCompressor();
                           tmp.ArchiveFormat = OutArchiveFormat.SevenZip;
                           tmp.CompressionMethod = CompressionMethod.Lzma;
                           tmp.CompressionLevel = CompressionLevel.Ultra;
                               tmp.FileCompressionStarted += (s, e) =>
                               {
                                   Dispatcher.Invoke(() => lblPorcentage.Content = (String.Format("Comprimiendo... [{0}%] {1}",
                                       e.PercentDone, e.FileName)));
                               };
                           tmp.CompressionFinished += (s, e) => { Dispatcher.Invoke(() => lblPorcentage.Content = ("Finished!")); };
                           tmp.CompressDirectory(folderToZip, @"test.7z");
                       });
                   }
               });
           });
       }

       private void SevenZipCompresorA()
       {
           System.Threading.Tasks.Task.Run(() =>
           {
               Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog();
           ofd.Title = "Archivos a Comprimir";
           ofd.Filter = "Archivos a Comprimir|*.*";
           ofd.Multiselect = true;
           if ((ofd.ShowDialog() == true))
           {
               //StreamWriter sw = new StreamWriter("listfile.lst");
               //foreach (string n in ofd.FileNames)
               //{
               //    sw.WriteLine(n);
               //}
               //sw.Close();

               System.Threading.Tasks.Task.Run(() =>
               {
                   var tmp = new SevenZipCompressor();
                   tmp.ArchiveFormat = OutArchiveFormat.SevenZip;
                   tmp.CompressionMethod = CompressionMethod.Lzma;
                   tmp.CompressionLevel = CompressionLevel.Ultra;
                   tmp.FileCompressionStarted += (s, e) =>
                   {
                       Dispatcher.Invoke(() => lblPorcentage.Content = (String.Format("Comprimiendo... [{0}%] {1}",
                           e.PercentDone, e.FileName)));
                   };
                   tmp.CompressionFinished += (s, e) => { Dispatcher.Invoke(() => lblPorcentage.Content = ("Finished!")); };
                   tmp.CompressFiles(@"test.7z", ofd.FileName);
               });

           }
           });
       }


Aclaro ambos funcionan de manera exitosa y pueden probarlo.

este es el codigo de mi proyecto base.

Código (csharp) [Seleccionar] Expandir


public void metodoDirectorio()
       {

           SpeechSynthesizer habla = new SpeechSynthesizer();
           AvisoVisual aviso = new AvisoVisual();
           aviso.Top = 1;
           aviso.Left = 600;
           aviso.Visibility = Visibility.Visible;

           System.Threading.Tasks.Task.Run(() =>
           {
               System.Windows.Forms.FolderBrowserDialog ofd = new System.Windows.Forms.FolderBrowserDialog();
               ofd.Description = "Seleccione la carpeta a comprimir";
               ofd.RootFolder = Environment.SpecialFolder.Desktop;

               Dispatcher.Invoke(() =>
               {
                   if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                   {
                       string folderToZip = ofd.SelectedPath;

                       System.Threading.Tasks.Task.Run(() =>
                       {
                           var tmp = new SevenZipCompressor();
                           tmp.ArchiveFormat = OutArchiveFormat.SevenZip;
                           tmp.CompressionMethod = CompressionMethod.Lzma;
                           tmp.CompressionLevel = CompressionLevel.Ultra;
                           tmp.FileCompressionStarted += (s, e) =>
                           {
                               Dispatcher.Invoke(() => aviso.Content = (String.Format("Comprimiendo... [{0}%] {1}",
                                   e.PercentDone, e.FileName)));
                           };
                           tmp.CompressionFinished += (s, e) => Dispatcher.Invoke(() => aviso.Close());
                           tmp.CompressDirectory(folderToZip, File.Create(Settings.Default.directorioComprimidos));
                       });
                   }
                   else
                   {
                       aviso.Close();
                   }
               });
           });            
       }
       public void metodoArchivo()
       {
           AvisoVisual aviso = new AvisoVisual();
           aviso.Top = 1;
           aviso.Left = 600;
           aviso.Visibility = Visibility.Visible;

           System.Threading.Tasks.Task.Run(() =>
           {
               Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog();
               ofd.Title = "Archivos a Comprimir";
               ofd.Filter = "Archivos a Comprimir|*.*";
               ofd.Multiselect = true;
               if ((ofd.ShowDialog() == true))
               {
                   System.Threading.Tasks.Task.Run(() =>
                   {
                       var tmp = new SevenZipCompressor();
                       tmp.ArchiveFormat = OutArchiveFormat.SevenZip;
                       tmp.CompressionMethod = CompressionMethod.Lzma;
                       tmp.CompressionLevel = CompressionLevel.Ultra;

                       tmp.FileCompressionStarted += (s, e) =>
                       {
                           Dispatcher.Invoke(() => aviso.Content = (String.Format("Comprimiendo... [{0}%] {1}",
                               e.PercentDone, e.FileName)));
                       };
                       tmp.CompressionFinished += (s, e) => { Dispatcher.Invoke(() => aviso.Close()); };
                       tmp.CompressFiles(Settings.Default.directorioComprimidos, ofd.FileName);
                   });
               }
               else
               {
                   Dispatcher.Invoke(() => aviso.Close());
               }
           });            
       }


como se podran fijar la unica diferencia es el cambio de direccion en la parte de salida del archivo.

El error del codigo 2 es: "acceso denegado a la ruta de acceso 'C:\'.' en realidad a la ruta que le ponga da ese error y no enteindo ni se por que, espero pueda alguien ayudarme.

PD. Despues de buscar solucion ahora me envia el archivo a el lugar que quiera pero sin nombre alguno y eso asigno un nombre.

Buenas noches amigos, me gustaria que me opinaran en algo simple que no le encuentro solucion.

Eh creado un Slider para a mi aplicacion poder cambiar su opacidad, el valor se guarda en una settings, y no hay problema, pero quice que el valor a medida que uno lo cambia se mostrara en un label y es aqui donde eh fallado no encuentro como.

Lo que inicial mente logre es mostrar en la carga inicial del programa el valor que esta en el momento actual guardado en la setting.

Código [Seleccionar] Expandir

        private void Window_Activated(object sender, EventArgs e)
        {
            lblOpaValor.Content = Settings.Default.opacidad;           
        }

mas no poder mostrar el valor a medida que uno lo cambie.

Intente asi pero falle entro otras muchas formas y nada.

Código [Seleccionar] Expandir

        private void sldOpa_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        {
            double valorOpacidad = e.NewValue;
            lblOpaValor.Content = valorOpacidad.ToString();
        }

Agradeceria sus ayudas , gracias por el tiempo.

utilizo el SpeechRecognitionEngine
con el la propiedad de "SetInputToDefaultAudioDevice" necesito que me ayuden a realizar una busqueda de los microfonos activos por medio de un foreach
aqui muestro dos metodos con los que me resulta la obtencion de los dispositivos pero ninguno resulta al yo seleccionar el microfono no me lo cambia, algo falta pero no se que es, segun es recargar el SetInputToDefaultAudioDevice luego de un Disposed pero no se como hacerlo.

Código [Seleccionar] Expandir

private void CargaMicro()
       {
           ManagementObjectSearcher mo = new ManagementObjectSearcher("select * from Win32_SoundDevice");

           foreach (ManagementObject soundDevice in mo.Get())
           {
               //Console.WriteLine(soundDevice.GetPropertyValue("DeviceId"));
               //Console.WriteLine(soundDevice.GetPropertyValue("Manufacturer"));
               mic.Items.Add(soundDevice.GetPropertyValue("Name"));              
           }
           //MMDeviceEnumerator names = new MMDeviceEnumerator();
           //var devices = names.EnumerateAudioEndPoints(DataFlow.Capture, DeviceState.Active);
           //foreach (var device in devices)
           //{
           //    mic.Items.Add(device.FriendlyName);
           //}
       }
ya que por defecto me toma el microfono predeterminado, espero puedan ayudarme, estoy usando estos codigos ambos me dan en el combobox la lista de los dispositivoos de captura de sonido, pero no encuentro la forma que al yo seleccionarlo funcionen

antes de eso cargo este metodo

Código [Seleccionar] Expandir

private void ActivarEscucha()
       {
           escucha.SetInputToDefaultAudioDevice();
           escucha.RecognizeAsync(RecognizeMode.Multiple);
           escucha.SpeechRecognized += Escucha_SpeechRecognized;
           escucha.AudioLevelUpdated += Escucha_AudioLevelUpdated;
       }

Eh creado este codigo con la finalidad de poder copiar todo lo que hable en un cuadro de texto, pero quiero que se pueda hacer fuera del cuadro de texto.

Aqui el codigo que implemente

Código (csharp) [Seleccionar] Expandir

using System.Windows;
using System.Speech.Synthesis;
using System.Speech.Recognition;

namespace Test
{
    public partial class MainWindow : Window
    {       
        PromptBuilder dictado = new PromptBuilder();
        SpeechSynthesizer habla = new SpeechSynthesizer();
        SpeechRecognitionEngine escucha = new SpeechRecognitionEngine();
        string speech;
        public MainWindow()
        {
            InitializeComponent();
            ActivarEscucha();
        }

 
        private void ActivarEscucha()
        {
            escucha.SetInputToDefaultAudioDevice();
            escucha.LoadGrammar(new DictationGrammar());
            escucha.RecognizeAsync(RecognizeMode.Multiple);
            escucha.SpeechRecognized += Escucha_SpeechRecognized;
            habla.SpeakAsync("Esperando Dictado");
        }

        private void Escucha_SpeechRecognized(object sender, SpeechRecognizedEventArgs e)
        {
            speech = e.Result.Text;
    // dictado.AppendText(speech);       
        textbox.AppendText(speech); <-- si yo coloco esta linea, me escribe lo que hable en el textbox, yo necesito es que lo escriba fuera del textbox

        }
    }
}


Espero puedan ayudarme a solventar este problema , gracias.

Hola nuevamente , estoy usando un codigo capaz de bajar videos de youtube y funciona de manera espectacular mi problema es que no se como direccionar el archivo descargado a una carpeta que yo le asigne.
Tyrrrz/YoutubeExplode

Es ese el codigo que uso, y tome de prueba el codigo que tiene de ejemplo llamado "ConsoleDemo"

este se utiliza pegando la direccion del video de youtube pero lo crea en el mismo directorio raiz, si alguien lo ha usado que me pueda ayudar le estare muy agradecido.

Aqui el codigo que plantea

Código (csharp) [Seleccionar] Expandir

using System;
using System.IO;
using System.Threading.Tasks;
using Tyrrrz.Extensions;
using YoutubeExplode;
using YoutubeExplode.Models.MediaStreams;

namespace DemoConsole
{
   public static class Program
   {
       /// <summary>
       /// If given a YouTube URL, parses video id from it.
       /// Otherwise returns the same string.
       /// </summary>
       private static string NormalizeId(string input)
       {
           if (!YoutubeClient.TryParseVideoId(input, out var id))
               id = input;
           return id;
       }

       /// <summary>
       /// Turns file size in bytes into human-readable string
       /// </summary>
       private static string NormalizeFileSize(long fileSize)
       {
           string[] units = { "B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB" };
           double size = fileSize;
           var unit = 0;

           while (size >= 1024)
           {
               size /= 1024;
               ++unit;
           }

           return $"{size:0.#} {units[unit]}";
       }

       private static async Task MainAsync()
       {
           // Client
           var client = new YoutubeClient();

           // Get the video ID
           Console.Write("YouTube URL: ");
           var id = Console.ReadLine();
           id = NormalizeId(id);

           // Get the video info
           Console.WriteLine("Cargando...");
           var video = await client.GetVideoAsync(id);
           Console.WriteLine('-'.Repeat(100));

           // Print metadata
           Console.WriteLine($"Id: {video.Id} | Title: {video.Title} | Author: {video.Author}");

           // Get media stream info set
           var streamInfoSet = await client.GetVideoMediaStreamInfosAsync(id);

           // Get the most preferable stream
           Console.WriteLine("Buscando la mejor calidad de video...");
           var streamInfo = streamInfoSet.Muxed.WithHighestVideoQuality();
           var normalizedFileSize = NormalizeFileSize(streamInfo.Size);
           Console.WriteLine($"Quality: {streamInfo.VideoQualityLabel} | Container: {streamInfo.Container} | Size: {normalizedFileSize}");

           // Compose file name, based on metadata
           var fileExtension = streamInfo.Container.GetFileExtension();
           var fileName = $"{video.Title}.{fileExtension}";

           // Replace illegal characters in file name
           fileName = fileName.Replace(Path.GetInvalidFileNameChars(), '_');

           // Download video
           Console.WriteLine($"Descargando [{fileName}]...");
           Console.WriteLine('-'.Repeat(100));

           var progress = new Progress<double>(p => Console.Title = $"Gestor de Descarga YouTube [{p:P0}]");
           await client.DownloadMediaStreamAsync(streamInfo, fileName, progress);

           Console.WriteLine("Descarga completa!");
           Console.ReadKey();
       }

       public static void Main(string[] args)
       {
           // This demo prompts for video ID, gets video info and downloads one media stream
           // It's intended to be very simple and straight to the point
           // For a more complicated example - check out the WPF demo

           Console.Title = "Gestor de Descarga YouTube";

           // Main method in consoles cannot be asynchronous so we run everything synchronously
           MainAsync().GetAwaiter().GetResult();
       }
   }
}