【VS快捷键的使用】

已于 2023-10-24 17:27:11 修改
阅读量528 收藏
点赞数
文章标签： tornado plotly
于 2023-03-22 09:03:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41610493/article/details/129702138
版权
文章介绍了如何重置IDE的快捷键设置，以及Reshaper的使用，特别是利用Reshaper进行RSA密钥生成、导入导出、加密和解密数据的方法。代码示例展示了RSA加密解密过程，并提供了与文件操作相关的辅助函数。
摘要由CSDN通过智能技术生成

官网说明
快捷键不好用， 工具–选项–环境–键盘 然后选择重置，点击确定，快捷键就可以重新使用了。

命令键盘快捷方式 [特殊上下文]命令 ID
CompileCtrl+F7生成.编译
提取方法Ctrl+R、Ctrl+M重构.提取方法
下一个书签Ctrl+K、Ctrl+N编辑.下一书签
上一个书签Ctrl+K、Ctrl+P编辑.上一书签
切换书签Ctrl+K、Ctrl+K编辑.切换书签

Reshaper快捷键

Reshaper使用说明
官网说明详细
查看reshaper日志方法

  1. Please select ReSharper | Navigate | Go to action |log
    Resharper GenerateDocumentationComments
#include <iostream>
#include <fstream>

#include <openssl/bn.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <opencv2/opencv.hpp>
#pragma warning(disable:4996)
extern "C"
{
#include <openssl/applink.c>
};

#define DATA_BUFF_LENTH 129
#define RSA_BIT 1024

using namespace std;

typedef ios_base::openmode _Ios_Openmode;

class File
{
public:
	File(string strFilePath) :m_strFilePath(strFilePath) {};
	~File() {};
	bool open(_Ios_Openmode opreator);
	void close();
	void read(char* buff, int length);
private:
	fstream m_file;
	string m_strFilePath;
};

bool File::open(_Ios_Openmode opreator)
{
	m_file.open(m_strFilePath.c_str(), opreator);
	if (m_file.fail())
	{
		cout << "open file failure!" << endl;
		return false;
	}
	return true;
}

void File::close()
{
	m_file.close();
}

void File::read(char* buff, int length)
{
	m_file.read(buff, length);
}

class RSAKey
{
public:
	RSAKey(int rsabit, int bignum)
	{
		int r;

		m_rsa_bit = rsabit;
		m_rsa = RSA_new();
		m_pubKey = RSA_new();
		m_privateKey = RSA_new();
		m_bigNum = BN_new();

		BN_set_word(m_bigNum, bignum);

		r = RSA_generate_key_ex(m_rsa, m_rsa_bit, m_bigNum, NULL);

		if (r != 0) {
			printf("RSA_generate_key_ex error\n");
		}
	}

	~RSAKey()
	{
		RSA_free(m_rsa);
		RSA_free(m_pubKey);
		RSA_free(m_privateKey);
		BN_free(m_bigNum);
	}

	void exportPrivateKey(string fileName);
	void exportPublicKey(string fileName);
	void importPrivateKey(string fileName);
	void importPublicKey(string fileName);
	void printPublicKey();
	void printPrivateKey();

	void UsePrivateRSAKeyDecode(char* dsc, char* src)
	{
		int rsa_len = RSA_size(m_privateKey);
		int len = RSA_private_decrypt(rsa_len, (unsigned char*)src, (unsigned char*)dsc, m_privateKey, RSA_NO_PADDING);

		if (len < rsa_len) {
			return;
		}
	}

	void UsePublicRSAKeyEncode(char* dsc, char* src)
	{
		int rsa_len = RSA_size(m_pubKey);
		int len = RSA_public_encrypt(rsa_len, (unsigned char*)src, (unsigned char*)dsc, m_pubKey, RSA_NO_PADDING);

		if (len < rsa_len) {
			return;
		}
	}

	void readCiphertext(char* buff, int length, string fileName)
	{
		FILE* ifile = fopen(fileName.c_str(), "rb");
		if (ifile == NULL) {
			cout << "Failed to open file" << endl;
			return;
		}
		int i = 0;
		while (i < DATA_BUFF_LENTH) {
			unsigned char c;
			fread(&c, sizeof(c), 1, ifile);
			buff[i++] = (char)c;
		}
		fclose(ifile);
	}

	void writeCiphertext(char* buff, int length, string fileName)
	{
		FILE* ofile = fopen(fileName.c_str(), "wb");
		if (ofile == NULL) {
			cout << "Failed to open file" << endl;
			return;
		}
		for (int i = 0; i < DATA_BUFF_LENTH; i++) {
			unsigned char c = buff[i];
			fwrite(&c, sizeof(c), 1, ofile);
		}
		fclose(ofile);
	}

	void readCiphertextEx(char* buff, int length, string fileName)
	{
		FILE* ifile = fopen(fileName.c_str(), "r");
		if (ifile == NULL) {
			cout << "Failed to open file" << endl;
			return;
		}
		int i = 0;
		while (i < DATA_BUFF_LENTH) {
			int num;
			fscanf(ifile, "%d", &num);
			buff[i++] = num;
		}
		fclose(ifile);
	}

	void writeCiphertextEx(char* buff, int length, string fileName)
	{
		FILE* ofile = fopen(fileName.c_str(), "w");
		if (ofile == NULL) {
			cout << "Failed to open file" << endl;
			return;
		}
		for (int i = 0; i < DATA_BUFF_LENTH; i++) {
			unsigned char c = (char)buff[i];
			fprintf(ofile, "%d \n", c);
		}
		fclose(ofile);
	}
private:
	BIGNUM* m_bigNum;
	RSA* m_rsa;
	int m_rsa_bit;
	RSA* m_pubKey;
	RSA* m_privateKey;
};


void RSAKey::printPublicKey()
{
	RSA_print_fp(stdout, m_pubKey, 11);
}

void RSAKey::printPrivateKey()
{
	RSA_print_fp(stdout, m_privateKey, 11);
}

void RSAKey::exportPrivateKey(string fileName)
{
	if (1) {
		BIO* out;

		//long BIO_get_mem_data(BIO *b, char **pp);
		//BIO_set_mem_buf(BIO *b, BUF_MEM *bm, int c);
		//BIO_get_mem_ptr(BIO *b, BUF_MEM **pp);

		out = BIO_new(BIO_s_mem()); //BIO_s_file()

		if (out) {
			int r = PEM_write_bio_RSAPrivateKey(out, m_rsa, NULL, NULL, 0, NULL, NULL);

			if (r) {
				char* data;
				long len;

				if (0) {
					//int read = BIO_nread0(out, &data);
					len = BIO_get_mem_data(out, &data);
				}
				else {
					BUF_MEM* mem;
					int rr = BIO_get_mem_ptr(out, &mem);
					len = mem->length;
					data = mem->data;
				}

				FILE* ifile;
				ifile = fopen(fileName.c_str(), "wb");

				if (ifile) {
					fwrite(data, 1, len, ifile);
					fclose(ifile);
				}

				BIO_free(out);
			}
		}
	}
}

void RSAKey::exportPublicKey(string fileName)
{
	FILE* ifile;

	ifile = fopen(fileName.c_str(), "wb");

	if (ifile) {
		PEM_write_RSAPublicKey(ifile, m_rsa);

		fclose(ifile);
	}
}

void RSAKey::importPrivateKey(string fileName)
{
	FILE* ifile;
	ifile = fopen(fileName.c_str(), "rb");

	if (0) {
		m_privateKey = PEM_read_RSAPrivateKey(ifile, NULL, NULL, NULL);
	}
	else {
		char* key;
		int key_len, readlen, r;

		r = fseek(ifile, 0, SEEK_END);
		key_len = ftell(ifile);
		key = (char*)malloc(key_len + 1);
		fseek(ifile, 0, SEEK_SET);
		readlen = fread(key, key_len, 1, ifile);
		key[key_len] = '\0';

		BIO* b = BIO_new_mem_buf((void*)key, key_len);
		if (b) {
			m_privateKey = PEM_read_bio_RSAPrivateKey(b, NULL, NULL, NULL);

			BIO_free(b);
		}
	}

	fclose(ifile);
}

void RSAKey::importPublicKey(string fileName)
{
	FILE* ifile;
	ifile = fopen(fileName.c_str(), "rb");
	m_pubKey = PEM_read_RSAPublicKey(ifile, NULL, NULL, NULL);

	fclose(ifile);
}

class FileReader {
public:

	static std::string readFileAndPrint(const std::string& filename)
	{
		char DataBuff[DATA_BUFF_LENTH];
		std::ifstream file(filename);

		if (!file.is_open()) {
			std::cerr << "无法打开文件: " << filename << std::endl;
			return "";
		}

		std::string content;
		while (!file.eof()) {
			file.read(DataBuff, (DATA_BUFF_LENTH - 1));
			std::streamsize bytesRead = file.gcount();
			DataBuff[bytesRead] = '\0';  // 添加空字符
			content += DataBuff;
			//std::cout << content;
		}

		file.close();
		return content;
	}

	static void deleteFile(const std::string& filename)
	{
		if (remove(filename.c_str()) != 0) {
			std::cerr << "删除文件失败: " << filename << std::endl;
		}
		else {
			std::cout << "成功删除文件: " << filename << std::endl;
		}
	}

	static void modifyImage(const std::string& inputFilename, const std::string& outputFilename)
	{
		cv::Mat img = cv::imread(inputFilename);

		if (img.empty()) {
			std::cerr << "无法打开图像: " << inputFilename << std::endl;
			return;
		}

		for (int y = 0; y < img.rows; ++y) {
			for (int x = 0; x < img.cols; ++x) {
				cv::Vec3b& pixel = img.at<cv::Vec3b>(y, x);

				for (int c = 0; c < 3; ++c) {
					int value = pixel[c];
					int tensAndAbove = value / 10 * 10;

					if (c == 0) { // Blue
						pixel[c] = tensAndAbove + 1;
					}
					else if (c == 1) { // Green
						pixel[c] = tensAndAbove + 2;
					}
					else if (c == 2) { // Red
						pixel[c] = tensAndAbove + 3;
					}
				}
			}
		}

		if (!cv::imwrite(outputFilename, img)) {
			std::cerr << "无法保存图像: " << outputFilename << std::endl;
		}
	}
	//这是一个基于C++的静态方法，用于获取char值的个位、十位和百位。如果没有十位或百位，该方法将返回零。
	static int getDigit(unsigned char value, int place)
	{
		int intValue = static_cast<int>(value);
		for (int i = 0; i < place; ++i) {
			intValue /= 10;
		}
		return intValue % 10;
	}
	//这是一个基于C++的静态方法，用于修改int值的个位数，同时保持其他位数不变。
	static int modifyOnesDigit(int value, int newOnesDigit)
	{
		return value / 10 * 10 + newOnesDigit;
	}

	static void ReadPic(string keyPath, const std::string& inImage, const std::string& strOutPaht)
	{
		std::ofstream file(strOutPaht, std::ios_base::app);
		if (!file.is_open()) {
			std::cerr << "无法打开文件: " << strOutPaht << std::endl;
			return;
		}
		size_t start = 0;

		std::string strContest;
		FILE* ifile;
		ifile = fopen(keyPath.c_str(), "rb");
		RSA* privateKey = NULL;
		char* key;
		int key_len, readlen, r;

		r = fseek(ifile, 0, SEEK_END);
		key_len = ftell(ifile);
		key = (char*)malloc(key_len + 1);
		fseek(ifile, 0, SEEK_SET);
		readlen = fread(key, key_len, 1, ifile);
		key[key_len] = '\0';

		BIO* b = BIO_new_mem_buf((void*)key, key_len);
		if (b) {
			privateKey = PEM_read_bio_RSAPrivateKey(b, NULL, NULL, NULL);
			BIO_free(b);
		}
		fclose(ifile);

		cv::Mat img = cv::imread(inImage);

		if (img.empty()) {
			std::cerr << "无法打开图像: " << inImage << std::endl;
			return;
		}
		int index = 0;
		char DataBuff[DATA_BUFF_LENTH];
		char dsc[DATA_BUFF_LENTH];
		for (int y = 0; y < img.rows; ++y) {
			for (int x = 0; x < img.cols; ++x) {
				cv::Vec3b& pixel = img.at<cv::Vec3b>(y, x);
				unsigned char ucValue = 0;
				for (int c = 0; c < 3; ++c) {
					int value = pixel[c];
					if (c == 0) {     // Blue
						ucValue += getDigit(pixel[c], 0) * 100;
					}
					else if (c == 1) { // Green
						ucValue += getDigit(pixel[c], 0) * 10;
					}
					else if (c == 2) { // Red
						ucValue += getDigit(pixel[c], 0);
					}
				}
				if (index >= DATA_BUFF_LENTH)
				{
					int rsa_len = RSA_size(privateKey);
					//不加密start
					//memcpy(dsc, DataBuff, DATA_BUFF_LENTH);
					//不加密end
					//加密start
					int len = RSA_private_decrypt(rsa_len, (unsigned char*)DataBuff, (unsigned char*)dsc, privateKey, RSA_NO_PADDING);
					if (len < rsa_len) {
						return;
					}
					//加密end
					file.write(dsc, DATA_BUFF_LENTH - 1);
			
					index = 0;
				}
				DataBuff[index++] = static_cast<char>(ucValue);
			}
		}
		file.close();
	}

	static void writePic(string keyPath, const std::string& filename, const std::string& inImage, const std::string& outImage)
	{
		FILE* ifile;
		ifile = fopen(keyPath.c_str(), "rb");
		RSA* pPubKey = PEM_read_RSAPublicKey(ifile, NULL, NULL, NULL);
		fclose(ifile);
		int rsa_len = RSA_size(pPubKey);

		char DataBuff[DATA_BUFF_LENTH];
		std::ifstream file(filename);

		cv::Mat img = cv::imread(inImage);

		if (img.empty()) {
			std::cerr << "无法打开图像: " << inImage << std::endl;
			return;
		}

		if (!file.is_open()) {
			std::cerr << "无法打开文件: " << filename << std::endl;
		}

		char dsc[DATA_BUFF_LENTH];
		int nCount = img.rows * img.cols;
		int nIndex = 0;
		while (!file.eof()) {
			file.read(DataBuff, (DATA_BUFF_LENTH - 1));
			std::streamsize bytesRead = file.gcount();
			DataBuff[bytesRead] = '\0';  // 添加空字符
			//不加密start
			//memcpy(dsc, DataBuff, DATA_BUFF_LENTH);
			//不加密end
			//加密start
			int len = RSA_public_encrypt(rsa_len, (unsigned char*)DataBuff, (unsigned char*)dsc, pPubKey, RSA_NO_PADDING);
			dsc[128] = '\0';
			if (len < rsa_len) {
				break;
			}
			//加密end
			if ((nIndex + DATA_BUFF_LENTH) >= nCount)
			{
				break;
			}
			for (int k = 0; k < DATA_BUFF_LENTH; k++)
			{
				unsigned char  ucValue = static_cast<unsigned char>(dsc[k]);
				int y = nIndex / img.cols;
				int x = nIndex % img.cols;
				cv::Vec3b& pixel = img.at<cv::Vec3b>(y, x);
				for (int c = 0; c < 3; ++c) {
					if(pixel[c] >240)
					{
						pixel[c] -= 10;
					}
					if (c == 0) {      // Blue
						int digit = getDigit(ucValue, 2);
						int value = modifyOnesDigit(pixel[c], digit);
						pixel[c] = value;
					}
					else if (c == 1) { // Green
						int digit = getDigit(ucValue, 1);
						int value = modifyOnesDigit(pixel[c], digit);
						pixel[c] = value;
					}
					else if (c == 2) { // Red
						int digit = getDigit(ucValue, 0);
						int value = modifyOnesDigit(pixel[c], digit);
						pixel[c] = value;
					}
				}
				nIndex++;
			}
		}
		file.close();

		if (!cv::imwrite(outImage, img)) {
			std::cerr << "无法保存图像: " << outImage << std::endl;
		}
	}

	static unsigned char charToUnsignedChar(char value) {
		return static_cast<unsigned char>(value);
	}

	static char unsignedCharToChar(unsigned char value) {
		return static_cast<char>(value);
	}
};

void MainTest()
{
	RSAKey rsa(RSA_BIT, RSA_F4);

	//rsa.exportPrivateKey("private.key");
	//rsa.exportPublicKey("public.key");

	rsa.importPublicKey("public.key");
	rsa.importPrivateKey("private.key");

	rsa.printPrivateKey();
	rsa.printPublicKey();

	char DataBuff[DATA_BUFF_LENTH];

	for (size_t i = 0; i < DATA_BUFF_LENTH; i++) {
		DataBuff[i] = 'A' + char(i % 26);
	}

	char enData[DATA_BUFF_LENTH];
	rsa.UsePublicRSAKeyEncode(enData, DataBuff);
	enData[128] = '\0';
	cout << "-----------------------------------" << endl;
	cout << "encode :" << enData << endl;
	cout << "-----------------------------------" << endl;
	rsa.writeCiphertextEx(enData, DATA_BUFF_LENTH, "ciphertext.txt");
	rsa.readCiphertextEx(DataBuff, DATA_BUFF_LENTH, "ciphertext.txt");

	char deData[DATA_BUFF_LENTH];
	rsa.UsePrivateRSAKeyDecode(deData, DataBuff);
	deData[128] = '\0';
	cout << "-----------------------------------" << endl;
	cout << "decode :" << deData << endl;
	cout << "-----------------------------------" << endl;
}

int main(int argc, char* argv[])
{
	//MainTest();
	FileReader::deleteFile("D:/step1out.png");
	FileReader::deleteFile("D:/XRBuildMapCopy.cpp");
	FileReader::writePic("public.key", "public.key", "D:/step1.png", "D:/step1out.png");
	FileReader::ReadPic("private.key", "D:/step1out.png", "D:/XRBuildMapCopy.cpp");

	//FileReader::modifyImage("D:/step1.png", "D:/step1out.png");
	//FileReader::modifyImage("D:/step1out2.png", "D:/step1out.png");
	return 0;
}


-----BEGIN RSA PUBLIC KEY-----
MIGJAoGBAN1YwhRPXSQocld8zFJ3FgezaPsudgqmUWLpRG62X3bRV4TQvbtUpa+h
73YFVfBY9cIOr9H1lWY0SJpR2lfA0INoJT04UrHy+O/43XjFBPXAcgdVk55PYHWs
Vr9yGJuXNshVHmjR3k3tHrjFzMJGXUux5wJrZHP2Z65n3hEIVYLfAgMBAAE=
-----END RSA PUBLIC KEY-----
华阙之梦
关注
Resharper的快捷键
cqzb的专栏
10-11 1728
Resharper 的快捷键 编辑 Ctrl + Space 代码完成 Ctrl + Shift + Space代码完成Ctrl + Alt + Space代码完成Ctrl + P 显示参数信息Alt + Insert 生成构造函数，属性，重载成员函数，实现接口Ctrl + Alt + J 生成if,try..catch,#region块Ctrl + / 注
VS快捷键
YYR5758的博客
11-11 1176
VS快捷键整理
vs 快捷键 整理大全
02-06
vs 常用的快捷键 自己多年使用VS后整理的 非常适用
ReSharper插件：.NET开发者的效率倍增器
最新发布
Unity打怪升级
08-16 341
在.NET开发的世界中，效率和代码质量是永恒的追求。ReSharper，由JetBrains公司开发的一款Visual Studio扩展，已经成为提升开发效率和改善代码质量的得力助手。本文将深入探讨ReSharper插件的一系列特性，以及它如何帮助开发者提高生产力。
【转载】VS快捷键，非常实用！
多多洛写技术博客的地方
05-08 1180
1、F12 这个键在查看代码的时候，特别有用。通过F12你可以快速的找到一个字段、函数、类的声明所在，通过 Ctrl+减号你可以快速的返回到函数的调用处。   对比Eclipse： VS　　　　　　　　　　Eclipse F12　　　　　　　　　　　F3 Ctrl+减号　　　　　　      Alt+左箭头 Ctrl+shift+减号　　　　   Alt
关于ReSharper的快捷键总结
weixin_34315189的博客
04-03 391
磨刀不误砍柴功，现对VS - Resharper的重要快捷键进行总结如下：一 ， Ctrl + Shift + Space （提示） 相当于FB当中的 Alt + /环境：当单词写到一半（或者没有写）而出现的代码提示消失时，这个就相当的给力了，效果如下：二 ， Ctrl + p （显示参数信息列表）环境 ： 当需要填写Method的参数，而参数提示信...
VS常用快捷键
Z少年的博客
10-24 166
F5 调试 Ctrl+F5 直接运行不调试 F12 转到定义 Alt+F12 查看定义 Ctrl+K+Ctrl+k 设置书签 Ctrl+K+Ctrl+N 跳转到下一个书签 Ctrl+K+Ctrl+F 格式化选中代码 Ctrl+K+Ctrl+S 外侧代码，如添加#region 等 Ctrl+R+Ctrl+E 封装字段 Ctrl+R+Ctrl+M 提取方法 Ctrl+R+Ctrl+...
VS 常用快捷键
weixin_40314351的博客
02-16 233
VS 复制快捷键 注释快捷键 代码对齐快捷键
VS2019使用快捷键将代码对齐的方法
08-19
VS2019使用快捷键将代码对齐的方法 VS2019使用快捷键将代码对齐的方法是指在 Visual Studio 2019 中使用快捷键来将代码对齐的方法。这种方法可以使代码更加整洁、易读和易维护。 在 VS2019 中，使用快捷键将代码...
VS_key.rar_vs快捷键
09-14
"VS_key.rar_vs快捷键"这个压缩包显然包含了一些关于在Visual Studio环境下提高编程效率的关键快捷键信息。了解并熟练使用这些快捷键能够极大地提升开发者的编码速度，减少鼠标操作，提高生产力。 在“VS 快捷键....
ReSharper2017注册文件
12-18
帮助用于ReSharper2017版本注册，步骤：安装ReSharper后，运行本文件，打开vs中的ReSharper->help->LicenseInformaion->修改UseLicenseServer的地址为本文件显示的runningat的地址；每次运行ReSharper前打开本文件即可免注册使用
excel快捷键使用大全,excel快捷键使用方法汇总.pdf
08-21
excel快捷键使用大全
Resharper详细教程
极客神殿
07-22 1万+
前言 原文中部分快捷键在8.2版本中不适用，我已改正，并用红色标注出来 在线API：https://www.jetbrains.com/help/resharper/Introduction__Index.html Reshaper是什么 即便是那些整天攻击 .NET 和 C# 的人，也常常不得不承认 Visual Studio 确实是个够强大的 IDE，除非他认为更少的 IDE 功能和命令行调试才是更强大的。可是，即便如此，仍阻止不了一些第三方的个人和厂商开发出一些插件来让 VS 变得更强大。Resh
ReSharper智能插件,ReSharper分析代码质量
q2315702359的博客
09-06 1041
ReSharper智能插件,ReSharper分析代码质量 　　ReSharper 是 Visual Studio 的智能插件。它配备了一组丰富的功能，包括智能编码辅助、即时错误突出显示和快速纠错。ReSharper智能插件 还支持代码重构、单元测试、导航和搜索。NAnt 和 MS 构建脚本编辑和 ASP.NET 编辑。ReSharper智能插件 许可证现在包括 ReSharper 和 ReSharper C++。 　　ReSharper 主要功能 　　ReSharper智能插件企鹅231570235
VisualStudio神级插件Resharper技巧基础入门到骨灰玩家使用全教程+Resharper性能优化
热门推荐
李小砍的技术博客
04-13 1万+
我相信很多做.NET开发的童鞋应该都装了Resharper这个重量级插件，但在我的印象里很多人也就只用到了他的一些基本功能，可能算是大材小用了吧，某天，在跟一同事进行结对编程的时候，看到同事也安装了Resharper，但是在写代码的时候，很多功能都没用到，于是我就在旁边提醒了他一些Resharper的快捷操作，所以还是给大家全面普及一下Resharper的基本使用吧，掌握了这些操作与技巧，让你真正...
VS+Resharper 共用的一些常用快捷键，速来收藏！
Heschel的博客
06-24 3271
**VS+Resharper 共用的一些常用快捷键： Ctrl + - 回退到上一步操作 Ctrl+B 进入资源代码，需要设置一下，才能进入dll更深入 Ctrl + / 注释 Ctrl+Shift+/ 区域内部注释 Ctrl+L 快速删除这一行代码 ALT+~ 导航所有，并且能看到 Intermediate Language （IL），即将.NET代码转化为机器语言的一个中间语言的缩写。在一定程度上，可以将其理解为伪汇编语言。 Ctrl+J
Resharper上手指南
枫若流鸿
11-27 1589
<br /><br />Resharper是我一直非常喜欢的工具。响当当的名声绝对不是吹牛皮吹出来的。如果你的公司在寻找一个提高开发人员效率的工具，那么首选应该是Resharper，这一笔投入是值得的。如果你想知道为什么，那么请看一看我的一系列上手指南。<br /><br />Resharper进阶一：简要介绍 <br />Resharper进阶二：快速定位 <br />Resharper进阶三：快速完成 <br />Resharper进阶四：万能的Alt+Enter <br />Resharper进阶五：
VS CTRL+W 无效,安装Resharper后
忆水思寒的博客
02-21 1018
解决方法:先重置默认快捷键,再打开Resharper快捷键,然后按ctrl+w会出现选择vs快捷键还是Resharper快捷键 一先回复默认键 1、VS设置工具–》选项–》环境–》键盘–》重置 2、RESHARPER -->Options–》Environment → Keyboard & Menus ，去掉Hide overridden勾选 ，keyboard shortcuts...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值